@inline-chat/hermes-agent-adapter 0.0.8 → 0.0.10

package/plugin/inline/adapter.py

@@ -48,6 +48,14 @@ from gateway.platforms.base import (
 )
 from gateway.platforms.helpers import strip_markdown
 
+from .message_actions import (
+    build_inline_agent_action_input,
+    build_inline_agent_action_turn_id,
+    build_inline_system_action_id,
+    parse_inline_agent_action_reply_target,
+    resolve_inline_message_action_ownership,
+)
+
 logger = logging.getLogger(__name__)
 
 _DEFAULT_SIDECAR_PORT = 8794
@@ -58,6 +66,7 @@ _DEDUP_MAX_SIZE = 5000
 _DEDUP_WINDOW_SECONDS = 48 * 3600
 _CHAT_INFO_CACHE_SECONDS = 10 * 60
 _CHAT_INFO_CACHE_MAX_SIZE = 512
+_BOT_SETTINGS_CHAT_INFO_TIMEOUT_SECONDS = 2.0
 _BOT_SETTINGS_MODEL_CATALOG_CACHE_SECONDS = 60
 _DEFAULT_CONTEXT_BACKFILL = "selective"
 _CONTEXT_BACKFILL_MODES = {"off", "selective", "always"}
@@ -346,20 +355,23 @@ def _target_from_chat_id(chat_id: str) -> Dict[str, str]:
     return {"chatId": raw}
 
 
-def _inline_sender_profile(event: Dict[str, Any], message: Optional[Dict[str, Any]] = None) -> Dict[str, str]:
+def _inline_sender_profile(event: Dict[str, Any], message: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
     raw = event.get("sender")
     if not isinstance(raw, dict) and isinstance(message, dict):
         raw = message.get("sender")
     if not isinstance(raw, dict):
         return {}
-    return {
+    profile: Dict[str, Any] = {
         key: str(raw.get(key) or "").strip()
         for key in ("id", "firstName", "lastName", "username")
         if str(raw.get(key) or "").strip()
     }
+    if isinstance(raw.get("bot"), bool):
+        profile["bot"] = raw["bot"]
+    return profile
 
 
-def _inline_sender_identity(profile: Dict[str, str]) -> tuple[str, str, str]:
+def _inline_sender_identity(profile: Dict[str, Any]) -> tuple[str, str, str]:
     first_name = str(profile.get("firstName") or "").strip()
     last_name = str(profile.get("lastName") or "").strip()
     username = str(profile.get("username") or "").strip().lstrip("@")
@@ -865,6 +877,7 @@ class InlineAdapter(BasePlatformAdapter):
         self._model_picker_sessions: "OrderedDict[str, Dict[str, Any]]" = OrderedDict()
         self._thread_action_sessions: "OrderedDict[str, Dict[str, Any]]" = OrderedDict()
         self._chat_info_cache: "OrderedDict[str, tuple[float, Dict[str, Any]]]" = OrderedDict()
+        self._bot_agent_cache: "OrderedDict[str, tuple[float, Dict[str, Any]]]" = OrderedDict()
         self._reply_thread_cache: "OrderedDict[str, str]" = OrderedDict()
         self._reply_thread_parent_reply_ids: "OrderedDict[str, set[str]]" = OrderedDict()
         self._reply_thread_parent_typing_targets: "OrderedDict[str, str]" = OrderedDict()
@@ -1001,7 +1014,14 @@ class InlineAdapter(BasePlatformAdapter):
         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)
+        try:
+            info = await asyncio.wait_for(
+                self._get_chat_info(chat_id),
+                timeout=_BOT_SETTINGS_CHAT_INFO_TIMEOUT_SECONDS,
+            )
+        except asyncio.TimeoutError:
+            logger.warning("[inline] agent settings chat metadata timed out")
+            info = {}
         if not info:
             return {
                 "access": "guideOnly",
@@ -2041,6 +2061,13 @@ class InlineAdapter(BasePlatformAdapter):
         if kind == "message.action.invoke":
             if await self._handle_action(event):
                 return
+            ownership = resolve_inline_message_action_ownership(event.get("actionId"))
+            if ownership.owner == "system" and ownership.explicit:
+                await self._answer_action(str(event.get("interactionId") or ""), "Action expired")
+                logger.info("[inline] dropped unhandled system action %s", event.get("actionId") or "")
+                return
+            await self._dispatch_agent_action(event)
+            return
         if kind == "reaction.add":
             await self._dispatch_reaction(event, added=True)
             return
@@ -2099,6 +2126,7 @@ class InlineAdapter(BasePlatformAdapter):
         return False
 
     async def _dispatch_message(self, event: Dict[str, Any], *, edit: bool = False) -> None:
+        agent_action = event.get("_inlineAgentAction") if isinstance(event.get("_inlineAgentAction"), dict) else None
         msg = event.get("message") or {}
         msg_id = str(msg.get("id") or "")
         chat_id = str(event.get("chatId") or msg.get("chatId") or "")
@@ -2134,6 +2162,13 @@ class InlineAdapter(BasePlatformAdapter):
             text = f"{text}\n{media_text}".strip() if text else media_text
         if not text and not media_urls:
             text = "[Inline message with no text]"
+        explicitly_mentions_me = self._message_entity_mentions_me(msg)
+        if event.get("_inlineSenderProvenanceVerified") is False and not explicitly_mentions_me:
+            self._remember_observed_context(chat_id, msg, text)
+            return
+        if sender_profile.get("bot") is True and not explicitly_mentions_me:
+            self._remember_observed_context(chat_id, msg, text)
+            return
 
         chat_type = self._chat_type_from_message(msg)
         thread_id = self._thread_id_from_message(msg)
@@ -2163,7 +2198,7 @@ class InlineAdapter(BasePlatformAdapter):
         )
         if has_command_target and not command_addressed_to_me:
             return
-        if await self._handle_thread_command(
+        if not agent_action and await self._handle_thread_command(
             chat_id=chat_id,
             msg_id=msg_id,
             text=text,
@@ -2172,7 +2207,7 @@ class InlineAdapter(BasePlatformAdapter):
             parent_chat_id=parent_chat_id,
         ):
             return
-        if await self._handle_follow_command(
+        if not agent_action and await self._handle_follow_command(
             chat_id=chat_id,
             msg_id=msg_id,
             from_id=from_id,
@@ -2227,6 +2262,7 @@ class InlineAdapter(BasePlatformAdapter):
             text = f"message:edited:{text}" if text else "message:edited"
         if (
             not edit
+            and not agent_action
             and not thread_id
             and self._should_create_reply_thread_for_message(
                 chat_id=chat_id,
@@ -2244,8 +2280,9 @@ class InlineAdapter(BasePlatformAdapter):
         mentioned_agent_id = self._mentioned_agent_id(msg)
         if mentioned_agent_id:
             try:
-                resolved_agent = await self._sidecar_call("/get-agent", {"agentId": mentioned_agent_id})
-                agent = resolved_agent.get("agent") if isinstance(resolved_agent.get("agent"), dict) else {}
+                agent = self._activated_agent(msg, mentioned_agent_id)
+                if not agent:
+                    agent = await self._resolve_bot_agent(mentioned_agent_id)
                 agent_name = str(agent.get("name") or "").strip()
                 agent_instructions = str(agent.get("instructions") or "").strip()
                 agent_skill = str(agent.get("skillKey") or agent.get("skill_key") or "").strip()
@@ -2253,7 +2290,7 @@ class InlineAdapter(BasePlatformAdapter):
                     specialization = agent_instructions or f'You are a specialized agent named "{agent_name}".'
                     channel_prompt = self._merge_channel_prompt(channel_prompt, specialization)
                 if agent_skill:
-                    auto_skill = [agent_skill]
+                    auto_skill = list(dict.fromkeys([*(auto_skill or []), agent_skill]))
             except Exception as exc:
                 logger.warning("[inline] failed to resolve mentioned Agent %s: %s", mentioned_agent_id, exc)
         entity_text = self._inline_entity_text(msg, str(msg.get("message") or ""))
@@ -2314,6 +2351,16 @@ class InlineAdapter(BasePlatformAdapter):
             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 ""),
+            }
 
         source = self.build_source(
             chat_id=chat_id,
@@ -2330,7 +2377,14 @@ class InlineAdapter(BasePlatformAdapter):
             message_type=message_type,
             source=source,
             raw_message=event,
-            message_id=msg_id,
+            message_id=(
+                build_inline_agent_action_turn_id(
+                    agent_action.get("messageId"),
+                    agent_action.get("interactionId"),
+                )
+                if agent_action
+                else msg_id
+            ),
             platform_update_id=int(event.get("seq") or 0) if str(event.get("seq") or "").isdigit() else None,
             media_urls=media_urls,
             media_types=media_types,
@@ -2343,24 +2397,70 @@ class InlineAdapter(BasePlatformAdapter):
             channel_context=channel_context,
             metadata=metadata,
             timestamp=self._timestamp(event.get("date") or msg.get("date")),
+            allow_gateway_control=not bool(agent_action),
         ))
 
+    async def _dispatch_agent_action(self, event: Dict[str, Any]) -> None:
+        interaction_id = str(event.get("interactionId") or "")
+        await self._answer_action(interaction_id, "")
+
+        chat_id = str(event.get("chatId") or "")
+        message_id = str(event.get("messageId") or "")
+        actor_user_id = str(event.get("actorUserId") or "")
+        if not chat_id or not message_id or not interaction_id or not actor_user_id:
+            logger.warning("[inline] ignored incomplete agent action event")
+            return
+        target = await self._fetch_message(chat_id, message_id)
+        if not target:
+            logger.info("[inline] ignored agent action for unavailable message %s", message_id)
+            return
+
+        synthetic_message = dict(target)
+        for stale_key in ("actions", "attachments", "entities", "media", "reactions", "replies"):
+            synthetic_message.pop(stale_key, None)
+        synthetic_message.update({
+            "id": message_id,
+            "chatId": chat_id,
+            "fromId": actor_user_id,
+            "message": build_inline_agent_action_input(event),
+            "out": False,
+            "mentioned": True,
+            "replyToMsgId": message_id,
+            "date": event.get("date") or target.get("date"),
+        })
+        sender = event.get("sender")
+        if isinstance(sender, dict):
+            synthetic_message["sender"] = sender
+        await self._dispatch_message({
+            **event,
+            "kind": "message.new",
+            "message": synthetic_message,
+            "_inlineAgentAction": dict(event),
+        })
+
     def _message_explicitly_mentions_me(self, msg: Dict[str, Any]) -> bool:
         if not self._me_id:
             return False
         if bool(msg.get("mentioned")):
             return True
+        if self._message_entity_mentions_me(msg):
+            return True
+        username = str(self._me_username or "").strip().lstrip("@")
+        text = str(msg.get("message") or "")
+        if not username or not text:
+            return False
+        return bool(re.search(rf"(^|\s)@{re.escape(username)}(?=$|[\s,.:;!?])", text, re.IGNORECASE))
+
+    def _message_entity_mentions_me(self, msg: Dict[str, Any]) -> bool:
+        if not self._me_id:
+            return False
         for entity in self._message_entities(msg):
             if self._entity_kind(entity) != "mention":
                 continue
             payload = self._entity_payload(entity, "mention")
             if self._entity_id(payload, "userId") == self._me_id:
                 return True
-        username = str(self._me_username or "").strip().lstrip("@")
-        text = str(msg.get("message") or "")
-        if not username or not text:
-            return False
-        return bool(re.search(rf"(^|\s)@{re.escape(username)}(?=$|[\s,.:;!?])", text, re.IGNORECASE))
+        return False
 
     async def _recover_self_join_mentions(self, event: Dict[str, Any]) -> bool:
         participant = event.get("participant") if isinstance(event.get("participant"), dict) else {}
@@ -2916,6 +3016,36 @@ class InlineAdapter(BasePlatformAdapter):
                 return agent_id
         return None
 
+    @staticmethod
+    def _activated_agent(msg: Dict[str, Any], agent_id: str) -> Optional[Dict[str, Any]]:
+        candidates = [msg]
+        raw = msg.get("raw")
+        if isinstance(raw, dict):
+            candidates.append(raw)
+        for container in candidates:
+            value = container.get("activatedAgent") or container.get("activated_agent")
+            if not isinstance(value, dict):
+                continue
+            value_id = value.get("id") or value.get("agentId") or value.get("agent_id")
+            if str(value_id or "") == agent_id:
+                return value
+        return None
+
+    async def _resolve_bot_agent(self, agent_id: str) -> Dict[str, Any]:
+        now = time.monotonic()
+        cached = self._bot_agent_cache.get(agent_id)
+        if cached and now - cached[0] < 60:
+            self._bot_agent_cache.move_to_end(agent_id)
+            return cached[1]
+
+        resolved = await self._sidecar_call("/get-agent", {"agentId": agent_id})
+        agent = resolved.get("agent") if isinstance(resolved.get("agent"), dict) else {}
+        self._bot_agent_cache[agent_id] = (now, agent)
+        self._bot_agent_cache.move_to_end(agent_id)
+        if len(self._bot_agent_cache) > 100:
+            self._bot_agent_cache.popitem(last=False)
+        return agent
+
     @staticmethod
     def _merge_channel_prompt(*parts: Optional[str]) -> Optional[str]:
         merged = [str(part).strip() for part in parts if str(part or "").strip()]
@@ -3443,7 +3573,12 @@ class InlineAdapter(BasePlatformAdapter):
             return None
 
     async def _handle_action(self, event: Dict[str, Any]) -> bool:
-        action_id = str(event.get("actionId") or "")
+        ownership = resolve_inline_message_action_ownership(event.get("actionId"))
+        if ownership.owner == "agent" and ownership.explicit:
+            return False
+        action_id = ownership.native_action_id
+        if ownership.owner == "system":
+            event = {**event, "actionId": action_id}
         if self._is_model_picker_action(action_id):
             if not await self._action_allowed(event):
                 return True
@@ -3877,6 +4012,48 @@ class InlineAdapter(BasePlatformAdapter):
         actions: Optional[Dict[str, Any]] = None,
     ) -> SendResult:
         target = self._target_for(chat_id, metadata)
+        agent_action_target = parse_inline_agent_action_reply_target(reply_to)
+        if agent_action_target:
+            chunks = self.truncate_message(self.format_message(content), self.MAX_MESSAGE_LENGTH)
+            edit_body: Dict[str, Any] = {
+                "target": target,
+                "messageId": agent_action_target,
+                "text": chunks[0],
+                "parseMarkdown": self._parse_markdown,
+                "actions": actions if actions is not None else {"rows": []},
+            }
+            first_result = await self._send_sidecar("/edit", edit_body)
+            if first_result.success:
+                self._mark_reply_thread_visible(target)
+                if len(chunks) == 1:
+                    return first_result
+                continuation_ids: List[str] = []
+                raw_responses: List[Any] = [first_result.raw_response]
+                previous_id = agent_action_target
+                for chunk in chunks[1:]:
+                    continuation = await self._send_sidecar("/send", {
+                        "target": target,
+                        "text": chunk,
+                        "parseMarkdown": self._parse_markdown,
+                        "replyToMsgId": previous_id,
+                    })
+                    raw_responses.append(continuation.raw_response)
+                    if not continuation.success:
+                        return continuation
+                    if continuation.message_id:
+                        previous_id = str(continuation.message_id)
+                        continuation_ids.append(previous_id)
+                return _send_result(
+                    success=True,
+                    message_id=previous_id,
+                    raw_response={"action_response": True, "responses": raw_responses},
+                    continuation_message_ids=tuple(continuation_ids),
+                )
+            logger.warning(
+                "[inline] agent action response edit failed; sending fallback: %s",
+                first_result.error,
+            )
+            reply_to = agent_action_target
         reply_to = self._reply_to_for_target(reply_to, target)
         chunks = self.truncate_message(self.format_message(content), self.MAX_MESSAGE_LENGTH)
         message_ids: List[str] = []
@@ -4086,6 +4263,7 @@ class InlineAdapter(BasePlatformAdapter):
             "path": safe_path,
             "kind": kind,
             "caption": caption,
+            "parseMarkdown": self._parse_markdown,
             "fileName": file_name,
             "mimeType": mime_type,
         }
@@ -4115,10 +4293,10 @@ class InlineAdapter(BasePlatformAdapter):
         self._remember(self._clarify_choices, clarify_id, clean_choices)
         lines = [f"Clarify: {question}", "", *[f"{i + 1}. {c}" for i, c in enumerate(clean_choices)]]
         actions = [
-            {"id": f"cl:{clarify_id}:{i}", "text": str(i + 1), "callback": f"cl:{clarify_id}:{i}"}
+            self._action(f"cl:{clarify_id}:{i}", str(i + 1))
             for i in range(len(clean_choices))
         ]
-        actions.append({"id": f"cl:{clarify_id}:other", "text": "Other", "callback": f"cl:{clarify_id}:other"})
+        actions.append(self._action(f"cl:{clarify_id}:other", "Other"))
         return await self._send_sidecar("/send", {
             "target": self._target_for(chat_id, metadata),
             "text": "\n".join(lines),
@@ -4164,9 +4342,9 @@ class InlineAdapter(BasePlatformAdapter):
             "text": f"{title}\n\n{message}",
             "parseMarkdown": self._parse_markdown,
             "actions": {"rows": [{"actions": [
-                {"id": f"sc:once:{confirm_id}", "text": "Approve Once", "callback": f"sc:once:{confirm_id}"},
-                {"id": f"sc:always:{confirm_id}", "text": "Always", "callback": f"sc:always:{confirm_id}"},
-                {"id": f"sc:cancel:{confirm_id}", "text": "Cancel", "callback": f"sc:cancel:{confirm_id}"},
+                self._action(f"sc:once:{confirm_id}", "Approve Once"),
+                self._action(f"sc:always:{confirm_id}", "Always"),
+                self._action(f"sc:cancel:{confirm_id}", "Cancel"),
             ]}]},
         })
 
@@ -4331,6 +4509,7 @@ class InlineAdapter(BasePlatformAdapter):
 
     @staticmethod
     def _action(action_id: str, text: str) -> Dict[str, str]:
+        action_id = build_inline_system_action_id(action_id)
         return {"id": action_id, "text": text, "callback": action_id}
 
     @staticmethod
@@ -4376,7 +4555,9 @@ class InlineAdapter(BasePlatformAdapter):
         return out
 
     def format_message(self, content: str) -> str:
-        return content if self._parse_markdown else strip_markdown(content)
+        # parseMarkdown=false means literal input at every Inline API boundary.
+        # Preserve that contract instead of silently rewriting the caller's text.
+        return content
 
     def _target_for(self, chat_id: str, metadata: Optional[Dict[str, Any]] = None) -> Dict[str, str]:
         thread_id = (metadata or {}).get("thread_id")

package/plugin/inline/cli.py

@@ -13,6 +13,9 @@ import re
 import shutil
 import subprocess
 import sys
+import urllib.error
+import urllib.parse
+import urllib.request
 
 from pathlib import Path
 
@@ -21,7 +24,19 @@ _MIN_NODE_MAJOR = 20
 _BOT_USERNAME_RE = re.compile(r"^[A-Za-z0-9_]+bot$", re.IGNORECASE)
 _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/0.0.10"
+_ENV_REFERENCE_RE = re.compile(r"^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$")
+
+
+class _RejectRedirects(urllib.request.HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        return None
+
+
+def _open_bot_api_probe(request: urllib.request.Request):
+    return urllib.request.build_opener(_RejectRedirects()).open(request, timeout=30)
 
 
 def gateway_setup() -> None:
@@ -411,13 +426,21 @@ def _machine_setup(args) -> int:
 def _status(args) -> int:
     from hermes_cli import gateway as hermes_gateway
 
+    raw_config = _read_inline_config(hermes_gateway)
     token = (
         hermes_gateway.get_env_value("INLINE_TOKEN")
         or hermes_gateway.get_env_value("INLINE_BOT_TOKEN")
+        or _resolve_config_value(hermes_gateway, raw_config.get("token"))
     )
     configured = bool(token)
     probe_requested = bool(getattr(args, "probe", False))
-    probe = _probe_inline_token(token) if configured and probe_requested else None
+    base_url = (
+        hermes_gateway.get_env_value("INLINE_BASE_URL")
+        or os.getenv("INLINE_BASE_URL")
+        or _resolve_config_value(hermes_gateway, raw_config.get("base_url"))
+        or "https://api.inline.chat"
+    )
+    probe = _probe_inline_token(token, base_url) if configured and probe_requested else None
     node = _node_status()
     sidecar = _sidecar_status(node)
     sidecar_bundled = bool(
@@ -471,37 +494,75 @@ def _plugin_version() -> str:
     return "unknown"
 
 
-def _probe_inline_token(token: str) -> dict:
-    inline_bin = _find_inline_cli()
-    if not inline_bin:
-        return {"ok": False, "error": "Inline CLI was not found for the credential probe."}
-    env = os.environ.copy()
-    for name in ("INLINE_TOKEN", "INLINE_BOT_TOKEN", "INLINE_OWNER_TOKEN", "INLINE_ACCESS_TOKEN"):
-        env.pop(name, None)
-    env["INLINE_TOKEN"] = token
+def _read_inline_config(hermes_gateway) -> dict:
     try:
-        result = subprocess.run(
-            [inline_bin, "--json", "--compact", "auth", "me"],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            timeout=30,
-            check=False,
-            env=env,
+        config = hermes_gateway.read_raw_config()
+    except (AttributeError, OSError, TypeError, ValueError):
+        return {}
+    if not isinstance(config, dict):
+        return {}
+    platforms = config.get("platforms")
+    platform_inline = platforms.get("inline") if isinstance(platforms, dict) else None
+    top_level_inline = config.get("inline")
+    merged = {}
+    if isinstance(top_level_inline, dict):
+        merged.update(top_level_inline)
+    if isinstance(platform_inline, dict):
+        merged.update(platform_inline)
+    return merged
+
+
+def _resolve_config_value(hermes_gateway, raw) -> str:
+    value = str(raw or "").strip()
+    match = _ENV_REFERENCE_RE.fullmatch(value)
+    if match:
+        name = match.group(1)
+        return str(hermes_gateway.get_env_value(name) or os.getenv(name) or "").strip()
+    return value
+
+
+def _probe_inline_token(token: str, base_url: str = "https://api.inline.chat") -> dict:
+    try:
+        base_url = str(base_url or "https://api.inline.chat").rstrip("/")
+        parsed = urllib.parse.urlsplit(base_url)
+        if parsed.scheme not in ("http", "https") or not parsed.netloc or parsed.query or parsed.fragment:
+            raise ValueError("invalid Inline base URL")
+        request = urllib.request.Request(
+            f"{base_url}/v1/getMe",
+            headers={
+                "Accept": "application/json",
+                "Authorization": f"Bearer {token}",
+                "User-Agent": _PROBE_USER_AGENT,
+            },
+            method="GET",
         )
-    except (OSError, subprocess.TimeoutExpired):
-        return {"ok": False, "error": "Inline credential probe could not run."}
-    if result.returncode != 0:
-        return {"ok": False, "error": "Inline rejected the configured credential."}
+        with _open_bot_api_probe(request) as response:
+            raw = response.read(_MAX_PROBE_RESPONSE_BYTES + 1)
+    except urllib.error.HTTPError as exc:
+        if exc.code in (401, 403):
+            return {"ok": False, "errorKind": "invalid_credential", "error": "Inline rejected the configured credential."}
+        return {"ok": False, "errorKind": "unavailable", "error": "Inline API credential probe failed."}
+    except ValueError:
+        return {"ok": False, "errorKind": "invalid_config", "error": "Inline API base URL is invalid."}
+    except (OSError, TimeoutError, urllib.error.URLError):
+        return {"ok": False, "errorKind": "unavailable", "error": "Inline API credential probe could not run."}
+    if len(raw) > _MAX_PROBE_RESPONSE_BYTES:
+        return {"ok": False, "errorKind": "invalid_response", "error": "Inline API credential probe returned too much data."}
     try:
-        payload = json.loads(result.stdout)
-    except (json.JSONDecodeError, TypeError):
-        return {"ok": False, "error": "Inline credential probe returned unreadable output."}
-    raw_id = payload.get("id") if isinstance(payload, dict) else None
+        payload = json.loads(raw)
+    except (json.JSONDecodeError, TypeError, UnicodeDecodeError):
+        return {"ok": False, "errorKind": "invalid_response", "error": "Inline API credential probe returned unreadable output."}
+    if not isinstance(payload, dict) or payload.get("ok") is not True:
+        return {"ok": False, "errorKind": "invalid_response", "error": "Inline API credential probe returned an unsuccessful response."}
+    result = payload.get("result")
+    user = result.get("user") if isinstance(result, dict) else None
+    if not isinstance(user, dict):
+        return {"ok": False, "errorKind": "invalid_response", "error": "Inline API credential probe returned no user identity."}
+    raw_id = user.get("id") if isinstance(user, dict) else None
     bot_user_id = str(raw_id).strip() if raw_id is not None else ""
     if not bot_user_id.isdigit() or int(bot_user_id) <= 0:
-        return {"ok": False, "error": "Inline credential probe returned no bot identity."}
-    username = str(payload.get("username") or "").strip().lstrip("@")
+        return {"ok": False, "errorKind": "invalid_response", "error": "Inline API credential probe returned no user identity."}
+    username = str(user.get("username") or "").strip().lstrip("@")
     return {
         "ok": True,
         "botUserId": bot_user_id,