@inline-chat/hermes-agent-adapter 0.0.5 → 0.0.6

package/plugin/inline/adapter.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 
 import asyncio
 import base64
+import hashlib
 import json
 import logging
 import math
@@ -15,6 +16,7 @@ import mimetypes
 import os
 import re
 import secrets
+import shlex
 import shutil
 import signal
 import socket
@@ -56,6 +58,7 @@ _DEDUP_MAX_SIZE = 5000
 _DEDUP_WINDOW_SECONDS = 48 * 3600
 _CHAT_INFO_CACHE_SECONDS = 10 * 60
 _CHAT_INFO_CACHE_MAX_SIZE = 512
+_BOT_SETTINGS_MODEL_CATALOG_CACHE_SECONDS = 60
 _DEFAULT_CONTEXT_BACKFILL = "selective"
 _CONTEXT_BACKFILL_MODES = {"off", "selective", "always"}
 _DEFAULT_THREAD_CONTEXT_LIMIT = 30
@@ -115,6 +118,13 @@ _INLINE_REPLY_THREAD_INTENT_RE = re.compile(
     re.IGNORECASE,
 )
 _INLINE_SETTINGS_VERSION = 1
+_INLINE_BOT_SETTINGS_VERSION = 1
+_INLINE_BOT_SETTINGS_UNAVAILABLE = 1
+_INLINE_BOT_SETTINGS_INVALID_VALUE = 2
+_INLINE_BOT_SETTINGS_STALE = 3
+_INLINE_BOT_SETTINGS_FAILED = 4
+_INLINE_BOT_SETTINGS_TONE_NEUTRAL = 1
+_INLINE_BOT_SETTINGS_TONE_WARNING = 3
 _INLINE_ENTITY_LIMIT = 12
 _INLINE_ENTITY_TEXT_LIMIT = 120
 
@@ -424,6 +434,26 @@ def _normalize_inline_command_name(raw: str) -> str:
     return name.strip("_")
 
 
+def _normalize_inline_username(raw: Any) -> Optional[str]:
+    username = str(raw or "").strip().lstrip("@").lower()
+    return username or None
+
+
+def _resolve_inline_targeted_command(text: str, bot_username: Optional[str]) -> tuple[str, bool, bool]:
+    match = re.match(
+        r"^/([a-z0-9_][a-z0-9_-]*)@([a-z0-9_]+)(\s.*)?$",
+        str(text or ""),
+        re.IGNORECASE | re.DOTALL,
+    )
+    if not match:
+        return text, False, False
+    target_username = _normalize_inline_username(match.group(2))
+    own_username = _normalize_inline_username(bot_username)
+    if not own_username or target_username != own_username:
+        return text, True, False
+    return f"/{match.group(1)}{match.group(3) or ''}", True, True
+
+
 def _normalize_inline_plugin_command_text(text: str) -> str:
     match = re.match(r"^/([a-z0-9_]+)(@[A-Za-z0-9_]+)?(\s.*)?$", str(text or ""), re.IGNORECASE | re.DOTALL)
     if not match or "_" not in match.group(1):
@@ -816,9 +846,14 @@ class InlineAdapter(BasePlatformAdapter):
         self._sidecar_supervisor_task: Optional[asyncio.Task] = None
         self._command_sync_task: Optional[asyncio.Task] = None
         self._inbound_task: Optional[asyncio.Task] = None
+        self._bot_settings_tasks: set[asyncio.Task] = set()
+        self._bot_settings_locks: Dict[str, asyncio.Lock] = {}
+        self._bot_settings_lock_users: Dict[str, int] = {}
+        self._bot_settings_model_catalog_cache: Optional[tuple[float, List[Dict[str, Any]]]] = None
         self._inbound_running = False
         self._http_client: Optional[httpx.AsyncClient] = None
         self._me_id: Optional[str] = None
+        self._me_username: Optional[str] = None
         self._seen_messages: Dict[str, float] = {}
         self._clarify_choices: "OrderedDict[str, List[str]]" = OrderedDict()
         self._clarify_sessions: "OrderedDict[str, str]" = OrderedDict()
@@ -931,6 +966,479 @@ class InlineAdapter(BasePlatformAdapter):
             self._reply_thread_overrides[key] = _reply_thread_mode(value, "auto")
         self._save_reply_thread_overrides()
 
+    @staticmethod
+    def _bot_settings_chat_type(info: Dict[str, Any]) -> str:
+        peer = info.get("peer")
+        if peer is None and isinstance(info.get("chat"), dict):
+            peer = info["chat"].get("peerId")
+        if isinstance(peer, dict):
+            peer_type = peer.get("peer") or peer.get("type") or {}
+            if isinstance(peer_type, dict) and peer_type.get("oneofKind") == "user":
+                return "dm"
+        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
+
+    async def _bot_settings_context(
+        self,
+        event: Dict[str, Any],
+        *,
+        model_catalog: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        chat_id = self._chat_key(event.get("chatId"))
+        actor_id = str(event.get("actorUserId") or "").strip()
+        if not chat_id or not actor_id:
+            return {"access": "guideOnly", "scope_id": chat_id or "unknown", "reply_threads": "auto"}
+
+        info = await self._get_chat_info(chat_id)
+        if not info:
+            return {
+                "access": "guideOnly",
+                "scope_id": chat_id,
+                "reply_threads": "auto",
+                "unavailable_reason": "chat_metadata",
+            }
+        parent_chat_id = self._chat_info_id(info, "parentChatId")
+        scope_chat_id = parent_chat_id or chat_id
+        is_reply_thread = bool(parent_chat_id)
+        chat_type = self._bot_settings_chat_type(info)
+        can_inspect = self._allowed(chat_type, actor_id) and self._chat_allowed(
+            chat_id,
+            chat_id if is_reply_thread else None,
+            parent_chat_id,
+        )
+        if not can_inspect:
+            return {"access": "guideOnly", "scope_id": scope_chat_id, "reply_threads": "auto"}
+
+        source = self.build_source(
+            chat_id=chat_id,
+            chat_name=self._chat_title_from_info(info) or chat_id,
+            chat_type=chat_type,
+            user_id=actor_id,
+            thread_id=chat_id if is_reply_thread else None,
+            parent_chat_id=parent_chat_id,
+        )
+        runner = self._bot_settings_runner()
+        can_modify = self._actor_authorized(chat_type, actor_id)
+        context: Dict[str, Any] = {
+            "access": "full" if can_modify else "readOnly",
+            "scope_id": scope_chat_id,
+            "chat_id": chat_id,
+            "actor_id": actor_id,
+            "chat_type": chat_type,
+            "is_reply_thread": is_reply_thread,
+            "following": self._chat_follow_mode_following(info),
+            "reply_threads": self._reply_thread_mode_for_chat(scope_chat_id),
+            "can_set_default_model": can_modify,
+            "source": source,
+            "runner": runner,
+            "model_options": [],
+            "model_map": {},
+            "reasoning_options": [],
+        }
+        if runner is None:
+            return context
+
+        try:
+            from gateway.run import _load_gateway_config
+            from hermes_cli.model_switch import list_picker_providers
+
+            cfg = _load_gateway_config() or {}
+            model_cfg = cfg.get("model") if isinstance(cfg, dict) else {}
+            if not isinstance(model_cfg, dict):
+                model_cfg = {"default": str(model_cfg or "")}
+            default_model = str(model_cfg.get("default") or model_cfg.get("model") or "").strip()
+            default_provider = str(model_cfg.get("provider") or "openrouter").strip()
+            session_key = runner._session_key_for_source(source)
+            override = (getattr(runner, "_session_model_overrides", {}) or {}).get(session_key) or {}
+            current_model = str(override.get("model") or default_model).strip()
+            current_provider = str(override.get("provider") or default_provider).strip()
+            providers = None
+            if model_catalog is None:
+                cached_catalog = self._bot_settings_model_catalog_cache
+                if cached_catalog and time.monotonic() - cached_catalog[0] < _BOT_SETTINGS_MODEL_CATALOG_CACHE_SECONDS:
+                    providers = cached_catalog[1]
+                    logger.info("[inline] AGENT_SETTINGS_TRACE phase=model_catalog cache=hit")
+                else:
+                    catalog_started = time.monotonic()
+                    providers = await asyncio.wait_for(
+                        asyncio.to_thread(
+                            list_picker_providers,
+                            current_provider=current_provider,
+                            current_base_url=str(override.get("base_url") or model_cfg.get("base_url") or ""),
+                            current_model=current_model,
+                            user_providers=cfg.get("providers") if isinstance(cfg, dict) else None,
+                            custom_providers=cfg.get("custom_providers") if isinstance(cfg, dict) else None,
+                            max_models=100,
+                            include_moa=True,
+                            excluded_providers=(cfg.get("model_catalog") or {}).get("excluded_providers")
+                            if isinstance(cfg.get("model_catalog"), dict) else None,
+                        ),
+                        timeout=5.0,
+                    )
+                    self._bot_settings_model_catalog_cache = (time.monotonic(), providers)
+                    logger.info(
+                        "[inline] AGENT_SETTINGS_TRACE phase=model_catalog cache=miss elapsed_ms=%d",
+                        int((time.monotonic() - catalog_started) * 1000),
+                    )
+            model_options: List[Dict[str, str]] = []
+            model_map: Dict[str, tuple[str, str]] = {}
+
+            def add_model(provider: str, model: str) -> Optional[str]:
+                provider = str(provider or "").strip()
+                model = str(model or "").strip()
+                if not provider or not model:
+                    return None
+                value = f"{provider}\t{model}"
+                if value not in model_map and len(model_options) < 100:
+                    label = model if model.startswith(f"{provider}/") else f"{provider}/{model}"
+                    model_map[value] = (provider, model)
+                    model_options.append({"value": value, "label": label})
+                return value
+
+            current_value = add_model(current_provider, current_model)
+            if providers is not None:
+                for provider in providers:
+                    provider_slug = str(provider.get("slug") or "").strip()
+                    if not provider_slug:
+                        continue
+                    for model in provider.get("models") or []:
+                        add_model(provider_slug, str(model).strip())
+            else:
+                previous_map = model_catalog.get("model_map") if isinstance(model_catalog, dict) else None
+                previous_options = model_catalog.get("model_options") if isinstance(model_catalog, dict) else None
+                if isinstance(previous_map, dict) and isinstance(previous_options, list):
+                    for option in previous_options:
+                        if not isinstance(option, dict):
+                            continue
+                        selected = previous_map.get(option.get("value"))
+                        if isinstance(selected, (list, tuple)) and len(selected) == 2:
+                            add_model(str(selected[0]), str(selected[1]))
+            default_value = add_model(default_provider, default_model)
+            context.update({"session_key": session_key})
+            if current_value:
+                context.update({
+                    "current_model": current_value,
+                    "default_model": default_value,
+                    "model_options": model_options,
+                    "model_map": model_map,
+                })
+
+            reasoning = runner._resolve_session_reasoning_config(
+                source=source,
+                session_key=session_key,
+                model=current_model,
+            )
+            if reasoning is None:
+                current_reasoning = "medium"
+            elif reasoning.get("enabled") is False:
+                current_reasoning = "none"
+            else:
+                current_reasoning = str(reasoning.get("effort") or "medium")
+            from hermes_constants import VALID_REASONING_EFFORTS
+            reasoning_values = ["none", *[str(value) for value in VALID_REASONING_EFFORTS]]
+            if current_reasoning not in reasoning_values:
+                reasoning_values.insert(0, current_reasoning)
+            context.update({
+                "reasoning": current_reasoning,
+                "reasoning_options": [
+                    {"value": value, "label": value.capitalize()} for value in dict.fromkeys(reasoning_values)
+                ],
+            })
+        except Exception as exc:
+            logger.debug("[inline] Hermes runtime settings unavailable: %s", exc)
+        return context
+
+    @staticmethod
+    def _bot_settings_revision(context: Dict[str, Any]) -> str:
+        visible = {
+            key: value for key, value in context.items()
+            if key not in {"runner", "source", "model_map"}
+        }
+        encoded = json.dumps(visible, sort_keys=True, separators=(",", ":"), default=str).encode("utf-8")
+        return f"hermes-v1-{hashlib.sha256(encoded).hexdigest()[:12]}"
+
+    def _bot_settings_document(self, context: Dict[str, Any]) -> Dict[str, Any]:
+        if context.get("access") == "guideOnly":
+            unavailable_text = (
+                "Hermes could not verify this chat. Try again when the bot is reachable."
+                if context.get("unavailable_reason") == "chat_metadata"
+                else "This chat is not allowed by Hermes' access policy."
+            )
+            return {
+                "version": _INLINE_BOT_SETTINGS_VERSION,
+                "revision": self._bot_settings_revision(context),
+                "sections": [{
+                    "id": "access",
+                    "items": [{
+                        "id": "access-guide",
+                        "label": "Hermes unavailable",
+                        "disabled": False,
+                        "control": {"oneofKind": "info", "info": {
+                            "text": unavailable_text,
+                            "tone": _INLINE_BOT_SETTINGS_TONE_WARNING,
+                        }},
+                    }],
+                }],
+            }
+
+        disabled = context.get("access") != "full"
+        disabled_reason = "Only an authorized Hermes controller can change this."
+        common = {"disabled": disabled, **({"disabledReason": disabled_reason} if disabled else {})}
+        runtime_items: List[Dict[str, Any]] = []
+        model_options = context.get("model_options") or []
+        current_model = context.get("current_model")
+        if current_model and model_options:
+            runtime_items.append({
+                "id": "model", "label": "Model", "description": "This session.", **common,
+                "control": {"oneofKind": "select", "select": {
+                    "value": current_model,
+                    "options": [{**option, "disabled": False} for option in model_options],
+                }},
+            })
+            if context.get("can_set_default_model") and current_model != context.get("default_model"):
+                runtime_items.append({
+                    "id": "model-default", "label": "Use as default", "description": "For new sessions.", **common,
+                    "control": {"oneofKind": "button", "button": {}},
+                })
+        reasoning_options = context.get("reasoning_options") or []
+        if context.get("reasoning") and reasoning_options:
+            runtime_items.append({
+                "id": "reasoning", "label": "Reasoning", **common,
+                "control": {"oneofKind": "select", "select": {
+                    "value": context["reasoning"],
+                    "options": [{**option, "disabled": False} for option in reasoning_options],
+                }},
+            })
+        if not runtime_items:
+            runtime_items.append({
+                "id": "runtime-unavailable", "label": "Runtime", "disabled": False,
+                "control": {"oneofKind": "info", "info": {
+                    "text": "Runtime options are not available for this session.",
+                    "tone": _INLINE_BOT_SETTINGS_TONE_NEUTRAL,
+                }},
+            })
+
+        sections: List[Dict[str, Any]] = [
+            {"id": "runtime", "items": runtime_items},
+            {"id": "attention", "items": [{
+                "id": "following", "label": "Following", "description": "Wake on eligible activity.", **common,
+                "control": {"oneofKind": "toggle", "toggle": {"value": bool(context.get("following"))}},
+            }]},
+            {"id": "replies", "items": [{
+                "id": "reply-threads", "label": "Reply in threads", **common,
+                "control": {"oneofKind": "select", "select": {
+                    "value": context.get("reply_threads") or "auto",
+                    "options": [
+                        {"value": "auto", "label": "Auto", "description": "Agent decides.", "disabled": False},
+                        {"value": "on", "label": "On", "description": "Always use threads.", "disabled": False},
+                        {"value": "off", "label": "Off", "description": "Stay in chat.", "disabled": False},
+                    ],
+                }},
+            }]},
+        ]
+        if disabled:
+            sections.append({"id": "access", "items": [{
+                "id": "read-only", "label": "Read-only", "disabled": False,
+                "control": {"oneofKind": "info", "info": {
+                    "text": "Access and reply mode inherit from the parent chat. Model, reasoning, and following stay with this thread."
+                    if context.get("is_reply_thread") else "A Hermes owner controls who can make changes.",
+                    "tone": _INLINE_BOT_SETTINGS_TONE_WARNING,
+                }},
+            }]})
+        return {
+            "version": _INLINE_BOT_SETTINGS_VERSION,
+            "revision": self._bot_settings_revision(context),
+            "sections": sections,
+        }
+
+    @staticmethod
+    def _bot_settings_problem(code: int, message: str, document: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        problem = {"code": code, "message": message}
+        if document is not None:
+            problem["currentDocument"] = document
+        return {"result": {"oneofKind": "problem", "problem": problem}}
+
+    @staticmethod
+    def _bot_settings_result_kind(response: Dict[str, Any]) -> str:
+        result = response.get("result") if isinstance(response, dict) else None
+        if not isinstance(result, dict):
+            return "invalid"
+        kind = str(result.get("oneofKind") or "invalid")
+        if kind == "problem" and isinstance(result.get("problem"), dict):
+            return f"problem:{result['problem'].get('code', 'unknown')}"
+        return kind
+
+    async def _answer_bot_settings(self, request_id: str, response: Dict[str, Any]) -> bool:
+        try:
+            await self._sidecar_call("/answer-bot-settings", {
+                "requestId": request_id,
+                "response": response,
+            })
+            return True
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:
+            logger.warning("[inline] agent settings answer expired: %s", exc)
+            return False
+
+    async def _handle_bot_settings_request(self, event: Dict[str, Any]) -> None:
+        request_id = str(event.get("requestId") or "").strip()
+        if not request_id:
+            return
+        started_at = time.monotonic()
+        logger.info(
+            "[inline] AGENT_SETTINGS_TRACE request=%s phase=request_start chat=%s",
+            request_id,
+            self._chat_key(event.get("chatId")),
+        )
+        try:
+            if int(event.get("version") or 0) != _INLINE_BOT_SETTINGS_VERSION:
+                response = self._bot_settings_problem(
+                    _INLINE_BOT_SETTINGS_UNAVAILABLE,
+                    "This Hermes version supports agent settings V1 only.",
+                )
+            else:
+                context = await self._bot_settings_context(event)
+                response = {"result": {"oneofKind": "document", "document": self._bot_settings_document(context)}}
+        except Exception as exc:
+            logger.warning("[inline] failed to load Hermes agent settings: %s", exc)
+            response = self._bot_settings_problem(_INLINE_BOT_SETTINGS_FAILED, "Hermes could not load settings.")
+        answered = await self._answer_bot_settings(request_id, response)
+        logger.info(
+            "[inline] AGENT_SETTINGS_TRACE request=%s phase=request_answer result=%s answered=%d elapsed_ms=%d",
+            request_id,
+            self._bot_settings_result_kind(response),
+            1 if answered else 0,
+            int((time.monotonic() - started_at) * 1000),
+        )
+
+    async def _apply_bot_setting(self, event: Dict[str, Any], context: Dict[str, Any]) -> None:
+        item_id = str(event.get("itemId") or "")
+        value = event.get("value") if isinstance(event.get("value"), dict) else {}
+        value_body = value.get("value") if isinstance(value.get("value"), dict) else {}
+        runner = context.get("runner")
+        source = context.get("source")
+        if item_id == "following" and value_body.get("oneofKind") == "boolValue":
+            enabled = bool(value_body.get("boolValue"))
+            target = (
+                {"userId": context["actor_id"]}
+                if context.get("chat_type") == "dm"
+                else {"chatId": context["chat_id"]}
+            )
+            await self._sidecar_call("/follow-mode", {
+                "target": target,
+                "mode": "following" if enabled else "unfollowed",
+            })
+            self._invalidate_chat_info(context["chat_id"])
+            return
+        if item_id == "reply-threads" and value_body.get("oneofKind") == "stringValue":
+            mode = str(value_body.get("stringValue") or "")
+            if mode not in {"auto", "on", "off"}:
+                raise ValueError("invalid reply mode")
+            self._set_reply_threads_for_chat(context["scope_id"], mode)
+            return
+        if runner is None or source is None:
+            raise ValueError("runtime unavailable")
+        if item_id in {"model", "model-default"}:
+            if item_id == "model-default" and not context.get("can_set_default_model"):
+                raise ValueError("default model unavailable")
+            selection = context.get("current_model") if item_id == "model-default" else value_body.get("stringValue")
+            selected = (context.get("model_map") or {}).get(selection)
+            if not selected:
+                raise ValueError("model unavailable")
+            provider, model = selected
+            command = (
+                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(
+                text=command,
+                message_type=MessageType.TEXT,
+                source=source,
+                raw_message=event,
+            ))
+            if result and re.search(r"(?:error|confirm|failed|could not)", str(result), re.IGNORECASE):
+                raise RuntimeError(str(result))
+            return
+        if item_id == "reasoning" and value_body.get("oneofKind") == "stringValue":
+            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)
+            return
+        raise ValueError("setting unavailable")
+
+    async def _handle_bot_settings_item(self, event: Dict[str, Any]) -> None:
+        lock_key = self._chat_key(event.get("chatId")) or "unknown"
+        lock = self._bot_settings_locks.setdefault(lock_key, asyncio.Lock())
+        self._bot_settings_lock_users[lock_key] = self._bot_settings_lock_users.get(lock_key, 0) + 1
+        try:
+            async with lock:
+                await self._handle_bot_settings_item_serialized(event)
+        finally:
+            remaining = self._bot_settings_lock_users.get(lock_key, 1) - 1
+            if remaining <= 0:
+                self._bot_settings_lock_users.pop(lock_key, None)
+                if self._bot_settings_locks.get(lock_key) is lock:
+                    self._bot_settings_locks.pop(lock_key, None)
+            else:
+                self._bot_settings_lock_users[lock_key] = remaining
+
+    async def _handle_bot_settings_item_serialized(self, event: Dict[str, Any]) -> None:
+        request_id = str(event.get("requestId") or "").strip()
+        if not request_id:
+            return
+        started_at = time.monotonic()
+        item_id = str(event.get("itemId") or "")
+        logger.info(
+            "[inline] AGENT_SETTINGS_TRACE request=%s phase=mutation_start chat=%s item=%s",
+            request_id,
+            self._chat_key(event.get("chatId")),
+            item_id,
+        )
+        try:
+            context = await self._bot_settings_context(event)
+            document = self._bot_settings_document(context)
+            if str(event.get("documentRevision") or "") != document["revision"]:
+                response = self._bot_settings_problem(
+                    _INLINE_BOT_SETTINGS_STALE,
+                    "Settings changed. Try again.",
+                    document,
+                )
+            elif context.get("access") != "full":
+                response = self._bot_settings_problem(
+                    _INLINE_BOT_SETTINGS_FAILED,
+                    "You do not have access to change this.",
+                    document,
+                )
+            else:
+                await self._apply_bot_setting(event, context)
+                next_context = await self._bot_settings_context(event, model_catalog=context)
+                response = {"result": {"oneofKind": "document", "document": self._bot_settings_document(next_context)}}
+        except ValueError as exc:
+            response = self._bot_settings_problem(_INLINE_BOT_SETTINGS_INVALID_VALUE, str(exc).capitalize())
+        except Exception as exc:
+            logger.warning("[inline] failed to update Hermes agent settings: %s", exc)
+            response = self._bot_settings_problem(_INLINE_BOT_SETTINGS_FAILED, "Hermes could not update this setting.")
+        answered = await self._answer_bot_settings(request_id, response)
+        logger.info(
+            "[inline] AGENT_SETTINGS_TRACE request=%s phase=mutation_answer item=%s result=%s answered=%d elapsed_ms=%d",
+            request_id,
+            item_id,
+            self._bot_settings_result_kind(response),
+            1 if answered else 0,
+            int((time.monotonic() - started_at) * 1000),
+        )
+
     @staticmethod
     def _has_reply_thread_intent(text: str) -> bool:
         normalized = re.sub(r"\s+", " ", str(text or "").strip())
@@ -1176,15 +1684,9 @@ class InlineAdapter(BasePlatformAdapter):
 
         self._chat_info_cache.pop(self._chat_key(chat_id), None)
         if command == "follow":
-            body = (
-                "Now explicitly following this Inline chat or thread. "
-                "Eligible activity can wake Hermes without an @mention."
-            )
+            body = "Following this chat—eligible messages can wake Hermes without an @mention."
         else:
-            body = (
-                "Explicitly unfollowed this Inline chat or thread. Automatic follow heuristics "
-                "will not turn following back on; mentions and replies can still wake Hermes."
-            )
+            body = "Unfollowed this chat—mentions and replies can still wake Hermes."
         await self.send(chat_id, body, reply_to=msg_id, metadata=metadata)
         return True
 
@@ -1241,6 +1743,11 @@ class InlineAdapter(BasePlatformAdapter):
             except Exception:
                 pass
             self._inbound_task = None
+        for task in list(self._bot_settings_tasks):
+            task.cancel()
+        if self._bot_settings_tasks:
+            await asyncio.gather(*self._bot_settings_tasks, return_exceptions=True)
+            self._bot_settings_tasks.clear()
         await self._stop_sidecar()
         if self._http_client is not None:
             await self._http_client.aclose()
@@ -1287,6 +1794,7 @@ class InlineAdapter(BasePlatformAdapter):
                         result = data.get("result") or {}
                         if result.get("connected"):
                             self._me_id = str(result.get("meId") or "") or None
+                            self._me_username = _normalize_inline_username(result.get("meUsername"))
                             return
                         if result.get("connectError"):
                             last_error = RuntimeError(str(result.get("connectError")))
@@ -1465,6 +1973,21 @@ class InlineAdapter(BasePlatformAdapter):
     def _is_bot_commands_too_much(error: Exception) -> bool:
         return bool(re.search(r"\bBOT_COMMANDS_TOO_MUCH\b", str(error), re.IGNORECASE))
 
+    def _schedule_bot_settings_task(self, operation: Any) -> None:
+        task = asyncio.get_event_loop().create_task(operation)
+        self._bot_settings_tasks.add(task)
+
+        def finished(completed: asyncio.Task) -> None:
+            self._bot_settings_tasks.discard(completed)
+            if completed.cancelled():
+                return
+            try:
+                completed.result()
+            except Exception as exc:
+                logger.warning("[inline] agent settings task failed: %s", exc)
+
+        task.add_done_callback(finished)
+
     async def _inbound_loop(self) -> None:
         if self._http_client is None:
             return
@@ -1497,6 +2020,8 @@ class InlineAdapter(BasePlatformAdapter):
             event = json.loads(line)
         except json.JSONDecodeError:
             return
+        self._me_id = str(event.get("meId") or self._me_id or "") or None
+        self._me_username = _normalize_inline_username(event.get("meUsername") or self._me_username)
         # Chat snapshots include mutable dialog and routing fields such as
         # followMode and lastMsgId. Invalidating here intentionally makes the
         # next group-message dispatch perform an extra GET_CHAT; correctness
@@ -1504,6 +2029,12 @@ class InlineAdapter(BasePlatformAdapter):
         # owns a coherent client-state cache.
         self._invalidate_chat_info(event.get("chatId"))
         kind = event.get("kind")
+        if kind == "bot.chatSettings.request":
+            self._schedule_bot_settings_task(self._handle_bot_settings_request(event))
+            return
+        if kind == "bot.chatSettings.item.invoke":
+            self._schedule_bot_settings_task(self._handle_bot_settings_item(event))
+            return
         if kind == "message.action.invoke":
             if await self._handle_action(event):
                 return
@@ -1543,7 +2074,19 @@ class InlineAdapter(BasePlatformAdapter):
         chat_id = str(event.get("chatId") or msg.get("chatId") or "")
         if not msg_id or not chat_id:
             return
-        dedup_key = f"edit:{chat_id}:{msg_id}:{msg.get('rev') or event.get('seq') or ''}" if edit else f"{chat_id}:{msg_id}"
+        if edit:
+            dedup_key = f"edit:{chat_id}:{msg_id}:{msg.get('rev') or event.get('seq') or ''}"
+        else:
+            event_seq = str(event.get("seq") or "").strip()
+            message_date = str(msg.get("date") or event.get("date") or "").strip()
+            # Update sequence identifies the delivery even when an older server
+            # reuses a deleted message ID. Date keeps sequence-less events safer.
+            if event_seq:
+                dedup_key = f"new:{chat_id}:seq:{event_seq}"
+            elif message_date:
+                dedup_key = f"new:{chat_id}:msg:{msg_id}:date:{message_date}"
+            else:
+                dedup_key = f"new:{chat_id}:msg:{msg_id}"
         if self._is_duplicate(dedup_key):
             return
         from_id = str(msg.get("fromId") or "")
@@ -1552,7 +2095,8 @@ class InlineAdapter(BasePlatformAdapter):
         sender_profile = _inline_sender_profile(event, msg)
         sender_name, sender_first_name, sender_username = _inline_sender_identity(sender_profile)
 
-        text = str(msg.get("message") or "").strip()
+        raw_message_text = str(msg.get("message") or "")
+        text = raw_message_text.strip()
         media_text, media_urls, media_types, message_type = await self._normalize_media(msg)
         if media_text:
             text = f"{text}\n{media_text}".strip() if text else media_text
@@ -1581,6 +2125,12 @@ class InlineAdapter(BasePlatformAdapter):
             return
         if chat_type == "group" and not self._chat_allowed(chat_id, thread_id, parent_chat_id):
             return
+        text, has_command_target, command_addressed_to_me = _resolve_inline_targeted_command(
+            text,
+            self._me_username,
+        )
+        if has_command_target and not command_addressed_to_me:
+            return
         if await self._handle_thread_command(
             chat_id=chat_id,
             msg_id=msg_id,
@@ -1618,7 +2168,7 @@ class InlineAdapter(BasePlatformAdapter):
             and not self._free_response_chat(chat_id, thread_id, parent_chat_id)
         )
         if mention_gate_active:
-            mentioned = bool(msg.get("mentioned")) or self._matches_mention(text)
+            mentioned = command_addressed_to_me or bool(msg.get("mentioned")) or self._matches_mention(text)
             reply_wakes_thread = reply_to_is_own and not self._strict_mention
             # Freshness only controls whether the server auto-follows a thread.
             # Once this dialog is FOLLOWING, it remains relevant until unfollowed.
@@ -1629,6 +2179,16 @@ class InlineAdapter(BasePlatformAdapter):
             if not mentioned and not reply_wakes_thread and not follow_mode_wakes_thread:
                 self._remember_observed_context(chat_id, msg, text)
                 return
+            # A leading explicit address to another person overwhelmingly means
+            # the turn is for them. It overrides only inferred follow/reply
+            # attention; an explicit address to this bot still wins.
+            if (
+                not mentioned
+                and (reply_wakes_thread or follow_mode_wakes_thread)
+                and self._starts_with_other_user_mention(msg, raw_message_text)
+            ):
+                self._remember_observed_context(chat_id, msg, text)
+                return
             if mentioned:
                 text = self._clean_mention(text)
         if edit:
@@ -2133,6 +2693,29 @@ class InlineAdapter(BasePlatformAdapter):
         text = str(value).strip()
         return text or None
 
+    def _starts_with_other_user_mention(self, msg: Dict[str, Any], message_text: str) -> bool:
+        if not self._me_id:
+            return False
+        candidates: List[tuple[int, int, Dict[str, Any]]] = []
+        for index, entity in enumerate(self._message_entities(msg)):
+            offset = _to_int(entity.get("offset"))
+            if offset is not None and offset >= 0:
+                candidates.append((offset, index, entity))
+        if not candidates:
+            return False
+        offset, _, first_entity = min(candidates, key=lambda item: (item[0], item[1]))
+        if self._entity_kind(first_entity) != "mention":
+            return False
+        payload = self._entity_payload(first_entity, "mention")
+        mentioned_user_id = self._entity_id(payload, "userId")
+        if not mentioned_user_id or mentioned_user_id == self._me_id:
+            return False
+        try:
+            utf16_prefix = message_text.encode("utf-16-le")[: offset * 2].decode("utf-16-le")
+        except UnicodeDecodeError:
+            return False
+        return not utf16_prefix.strip()
+
     def _format_entity_summary(self, entity: Dict[str, Any], message_text: str) -> Optional[str]:
         kind = self._entity_kind(entity)
         text = self._entity_slice(message_text, entity)
@@ -2715,8 +3298,6 @@ class InlineAdapter(BasePlatformAdapter):
 
     async def _handle_action(self, event: Dict[str, Any]) -> bool:
         action_id = str(event.get("actionId") or "")
-        chat_id = str(event.get("chatId") or "")
-        interaction_id = str(event.get("interactionId") or "")
         if self._is_model_picker_action(action_id):
             if not await self._action_allowed(event):
                 return True
@@ -2724,15 +3305,15 @@ class InlineAdapter(BasePlatformAdapter):
         if action_id.startswith("cl:"):
             if not await self._action_allowed(event):
                 return True
-            return await self._handle_clarify_action(action_id, chat_id, interaction_id)
+            return await self._handle_clarify_action(event)
         if action_id.startswith("appr:"):
             if not await self._action_allowed(event):
                 return True
-            return await self._handle_approval_action(action_id, chat_id, interaction_id)
+            return await self._handle_approval_action(event)
         if action_id.startswith("sc:"):
             if not await self._action_allowed(event):
                 return True
-            return await self._handle_slash_action(action_id, chat_id, interaction_id)
+            return await self._handle_slash_action(event)
         if action_id.startswith(_INLINE_THREADS_ACTION_PREFIX):
             return await self._handle_thread_action(event)
         return False
@@ -2778,14 +3359,16 @@ class InlineAdapter(BasePlatformAdapter):
             return None
         return self._chat_type_from_message(msg)
 
-    async def _handle_clarify_action(self, action_id: str, chat_id: str, interaction_id: str) -> bool:
+    async def _handle_clarify_action(self, event: Dict[str, Any]) -> bool:
+        action_id = str(event.get("actionId") or "")
         parts = action_id.split(":", 2)
         if len(parts) != 3:
             return False
         _, clarify_id, choice = parts
         session_key = self._clarify_sessions.get(clarify_id)
         if not session_key:
-            return False
+            await self._finish_action(event, "Prompt expired", "Clarification expired.")
+            return True
         if choice == "other":
             try:
                 from tools.clarify_gateway import mark_awaiting_text
@@ -2793,10 +3376,9 @@ class InlineAdapter(BasePlatformAdapter):
                 if not marked:
                     self._clarify_sessions.pop(clarify_id, None)
                     self._clarify_choices.pop(clarify_id, None)
-                    await self._answer_action(interaction_id, "Prompt expired")
+                    await self._finish_action(event, "Prompt expired", "Clarification expired.")
                     return True
-                await self._answer_action(interaction_id, "Type your answer")
-                await self.send(chat_id, "Type your answer:")
+                await self._finish_action(event, "Type your answer", "Type your answer:")
                 return True
             except Exception:
                 logger.exception("[inline] clarify other failed")
@@ -2810,59 +3392,76 @@ class InlineAdapter(BasePlatformAdapter):
             if resolved:
                 self._clarify_sessions.pop(clarify_id, None)
                 self._clarify_choices.pop(clarify_id, None)
-                await self._answer_action(interaction_id, "Answer recorded")
+                await self._finish_action(event, "Answer recorded", "Answer recorded.")
             else:
                 self._clarify_sessions.pop(clarify_id, None)
                 self._clarify_choices.pop(clarify_id, None)
-                await self._answer_action(interaction_id, "Prompt expired")
+                await self._finish_action(event, "Prompt expired", "Clarification expired.")
             return True
         except Exception:
             logger.exception("[inline] clarify action failed")
             return True
 
-    async def _handle_approval_action(self, action_id: str, chat_id: str, interaction_id: str) -> bool:
+    async def _handle_approval_action(self, event: Dict[str, Any]) -> bool:
+        action_id = str(event.get("actionId") or "")
         parts = action_id.split(":", 2)
         if len(parts) != 3:
             return False
         _, approval_id, choice = parts
+        choice = "once" if choice == "approve" else choice
         session_key = self._approval_sessions.get(approval_id)
-        if not session_key or choice not in {"approve", "deny"}:
+        if choice not in {"once", "session", "always", "deny"}:
             return False
+        if not session_key:
+            await self._finish_action(event, "Approval expired", "Approval expired; the command was not run.")
+            return True
         try:
             from tools.approval import resolve_gateway_approval
             count = resolve_gateway_approval(session_key, choice)
             self._approval_sessions.pop(approval_id, None)
             if not count:
-                await self._answer_action(interaction_id, "Approval expired")
+                await self._finish_action(event, "Approval expired", "Approval expired; the command was not run.")
                 return True
-            label = "Approved" if choice == "approve" else "Denied"
-            await self._answer_action(interaction_id, label)
-            await self.send(chat_id, f"{label}.")
+            labels = {
+                "once": ("Approved once", "Approved once."),
+                "session": ("Approved for session", "Approved for this session."),
+                "always": ("Always allowed", "Always allowed."),
+                "deny": ("Denied", "Denied."),
+            }
+            toast, text = labels[choice]
+            await self._finish_action(event, toast, text)
             return True
         except Exception:
             logger.exception("[inline] approval action failed")
             return True
 
-    async def _handle_slash_action(self, action_id: str, chat_id: str, interaction_id: str) -> bool:
+    async def _handle_slash_action(self, event: Dict[str, Any]) -> bool:
+        action_id = str(event.get("actionId") or "")
         parts = action_id.split(":", 2)
         if len(parts) != 3:
             return False
         _, choice, confirm_id = parts
         session_key = self._slash_sessions.get(confirm_id)
-        if not session_key or choice not in {"once", "always", "cancel"}:
+        if choice not in {"once", "always", "cancel"}:
             return False
+        if not session_key:
+            await self._finish_action(event, "Prompt expired", "Confirmation expired.")
+            return True
         try:
             from tools import slash_confirm as slash_confirm_mod
             result = await slash_confirm_mod.resolve(session_key, confirm_id, choice)
             self._slash_sessions.pop(confirm_id, None)
-            await self._answer_action(interaction_id, "Recorded")
-            if result:
-                await self.send(chat_id, result)
+            text = str(result or ("Cancelled." if choice == "cancel" else "Recorded."))
+            await self._finish_action(event, "Recorded", text)
             return True
         except Exception:
             logger.exception("[inline] slash confirm action failed")
             return True
 
+    async def _finish_action(self, event: Dict[str, Any], toast: str, text: str) -> None:
+        await self._answer_action(str(event.get("interactionId") or ""), toast)
+        await self._edit_action_message(event, text, {"rows": []})
+
     async def _handle_thread_action(self, event: Dict[str, Any]) -> bool:
         action_id = str(event.get("actionId") or "")
         chat_id = str(event.get("chatId") or "")
@@ -3381,19 +3980,36 @@ class InlineAdapter(BasePlatformAdapter):
             "actions": {"rows": [{"actions": actions}]},
         })
 
-    async def send_exec_approval(self, chat_id: str, command: str, session_key: str, description: str = "dangerous command", metadata: Optional[Dict[str, Any]] = None) -> SendResult:
+    async def send_exec_approval(
+        self,
+        chat_id: str,
+        command: str,
+        session_key: str,
+        description: str = "dangerous command",
+        metadata: Optional[Dict[str, Any]] = None,
+        allow_permanent: bool = True,
+        allow_session: bool = True,
+        smart_denied: bool = False,
+    ) -> SendResult:
         approval_id = secrets.token_hex(6)
-        self._remember(self._approval_sessions, approval_id, session_key)
         text = f"Command approval required\n\n```\n{command[:2000]}\n```\n\nReason: {description}"
-        return await self._send_sidecar("/send", {
+        if smart_denied:
+            text += "\n\nSmart DENY: owner override applies to this one operation only."
+        actions = [self._action(f"appr:{approval_id}:once", "Allow Once")]
+        if not smart_denied and allow_session:
+            actions.append(self._action(f"appr:{approval_id}:session", "Allow for Session"))
+            if allow_permanent:
+                actions.append(self._action(f"appr:{approval_id}:always", "Always Allow"))
+        actions.append(self._action(f"appr:{approval_id}:deny", "Deny"))
+        result = await self._send_sidecar("/send", {
             "target": self._target_for(chat_id, metadata),
             "text": text,
             "parseMarkdown": self._parse_markdown,
-            "actions": {"rows": [{"actions": [
-                {"id": f"appr:{approval_id}:approve", "text": "Approve", "callback": f"appr:{approval_id}:approve"},
-                {"id": f"appr:{approval_id}:deny", "text": "Deny", "callback": f"appr:{approval_id}:deny"},
-            ]}]},
+            "actions": {"rows": self._action_rows(actions)},
         })
+        if result.success:
+            self._remember(self._approval_sessions, approval_id, session_key)
+        return result
 
     async def send_slash_confirm(self, chat_id: str, title: str, message: str, session_key: str, confirm_id: str, metadata: Optional[Dict[str, Any]] = None) -> SendResult:
         self._remember(self._slash_sessions, confirm_id, session_key)