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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inline-chat/hermes-agent-adapter",
-  "version": "1.0.0-alpha.1",
+  "version": "1.0.0-alpha.3",
   "description": "Hermes Agent platform adapter for Inline, with a native Python plugin and bundled Inline realtime sidecar.",
   "license": "Apache-2.0",
   "type": "module",
@@ -88,9 +88,9 @@
     "testedHermesVersion": "0.22.5",
     "testedHermesCommit": "bf0203a794a07aac3ff764972ab9087baa4e4f4e"
   },
-  "gitHead": "da6de417e9cf98f5f36d44c2d380267e91335905",
+  "gitHead": "6294aa252af0ba2226afbed22d26a3fdf767a37d",
   "inlineRelease": {
-    "tag": "hermes-agent-v1.0.0-alpha.1",
-    "sha": "da6de417e9cf98f5f36d44c2d380267e91335905"
+    "tag": "hermes-agent-v1.0.0-alpha.3",
+    "sha": "6294aa252af0ba2226afbed22d26a3fdf767a37d"
   }
 }

package/plugin/inline/adapter.py

@@ -1176,18 +1176,19 @@ 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."""
         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)}
 
     @staticmethod
     def _bot_settings_chat_type(info: Dict[str, Any]) -> str:
@@ -2795,7 +2796,8 @@ class InlineAdapter(BasePlatformAdapter):
             _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)

package/plugin/inline/cli.py

@@ -27,7 +27,7 @@ _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.1"
+_PROBE_USER_AGENT = "inline-hermes-agent-adapter/1.0.0-alpha.3"
 _ENV_REFERENCE_RE = re.compile(r"^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$")
 
 

package/plugin/inline/plugin.yaml

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

package/plugin/inline/tools.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import json
+import http.client
 from collections import OrderedDict
 import os
 import re
@@ -87,12 +88,13 @@ _TURN_MESSAGES_MAX = 1000
 
 def remember_turn_message(
     *, session_chat_id: str, thread_id: str, message_id: str, chat_id: str, sender_id: str, sender_is_bot: bool,
-    chat_type: str = "", in_reply_thread: bool = False,
+    chat_type: str = "", parent_chat_id: str = "",
 ) -> None:
+    """``parent_chat_id`` is set only when the message itself was sent inside a reply thread."""
     key = (str(hermes_home()), str(session_chat_id or ""), str(thread_id or ""), str(message_id or ""))
     _turn_messages[key] = {
         "chatId": str(chat_id), "senderId": str(sender_id or ""), "senderIsBot": bool(sender_is_bot),
-        "chatType": str(chat_type or ""), "inReplyThread": bool(in_reply_thread),
+        "chatType": str(chat_type or ""), "parentChatId": str(parent_chat_id or ""),
     }
     _turn_messages.move_to_end(key)
     while len(_turn_messages) > _TURN_MESSAGES_MAX:
@@ -107,14 +109,15 @@ def _current_turn() -> Dict[str, Any]:
     known = _turn_messages.get((str(hermes_home()), session_chat, thread_id, message_id)) or {}
     # The turn already runs in a thread when reply threads moved it there (its message lives
     # in the parent chat) or when its message was sent inside the thread.
-    in_thread = bool(thread_id) and (bool(known.get("inReplyThread")) or (known.get("chatId") or session_chat) != thread_id)
+    parent_chat_id = known.get("parentChatId") or ""
+    in_thread = bool(thread_id) and (bool(parent_chat_id) or (known.get("chatId") or session_chat) != thread_id)
     return {
         "messageId": message_id,
         "chatId": known.get("chatId") or session_chat,
         "senderId": known.get("senderId") or "",
         "senderIsBot": known.get("senderIsBot"),
         "chatType": known.get("chatType") or "",
-        "inReplyThread": bool(known.get("inReplyThread")),
+        "parentChatId": parent_chat_id,
         "threadId": thread_id if in_thread else "",
     }
 
@@ -242,7 +245,10 @@ def tool_context_prompt(
         lines.append(f"- Current Inline reply thread: `{thread_id}`. Use this as `chat_id` for thread-scoped reads.")
         lines.append(f"- Link the current thread as `[this thread](inline://thread?id={thread_id})` when asked for a thread link.")
         if parent_chat_id:
-            lines.append(f"- Parent Inline chat: `{parent_chat_id}`.")
+            lines.append(
+                f"- Parent Inline chat: `{parent_chat_id}`. Earlier conversation lives there; "
+                "read it with get_history or search_messages using that chat_id."
+            )
     else:
         lines.append(f"- Current Inline chat: `{chat_id}`.")
         lines.append(f"- Link the current chat as `[this chat](inline://chat?id={chat_id})` when asked for a chat link.")
@@ -265,7 +271,7 @@ INLINE_TOOL_SCHEMA = {
         "When chat_id is omitted, the tool uses the current Inline reply thread if present, otherwise the current chat. "
         "Return normal assistant replies as text. Use send_message only for a button card or a different destination. "
         "Agent-owned button presses return as ordinary turns, and the normal response replaces the source card while clearing omitted buttons. "
-        "Use create_thread on the current triggering message when someone asks to continue in a thread; your answer then goes into it, so don't also post it in the chat. "
+        "Use create_thread on the current triggering message when someone asks to continue in a thread; your answer then goes into it, so don't also post it in the chat, and it starts with a short summary of the conversation so far. "
         "Use set_reply_threads when someone asks you to always or never answer in threads here. "
         "Use create_chat to create a new top-level destination outside the current conversation; it defaults to private, and public creation must explicitly set is_public with a space_id. "
         "Use search_messages for exact catch-up across older chat history. "
@@ -619,7 +625,7 @@ def _set_reply_threads(args: Dict[str, Any]) -> Dict[str, Any]:
         return owner.set_reply_threads_from_tool(
             chat_id=turn["chatId"],
             chat_type=turn.get("chatType") or "group",
-            in_reply_thread=bool(turn.get("inReplyThread")),
+            parent_chat_id=turn.get("parentChatId") or "",
             actor_id=turn["senderId"],
             actor_is_bot=bool(turn.get("senderIsBot")),
             mode=mode,
@@ -646,9 +652,18 @@ def _create_thread(args: Dict[str, Any]) -> Dict[str, Any]:
     thread_id = _inline_id(result.get("chatId"))
     if for_this_turn and owner is not None and thread_id:
         owner.note_turn_thread(turn["chatId"], turn["messageId"], thread_id)
+        result["message"] = _NEW_TURN_THREAD_MESSAGE
     return result
 
 
+# Later messages in a thread opened mid-turn start a new session that reads the thread's
+# history, so the answer that opens it carries what matters from this conversation.
+_NEW_TURN_THREAD_MESSAGE = (
+    "Your answer goes into this thread. Start it with a short summary of what matters from the "
+    "conversation so far; later messages here start a new session that reads this thread."
+)
+
+
 _FOLLOW_CONFIRMATIONS = {
     "following": "Following this chat.",
     "unfollowed": "Unfollowed; mentions and replies still reach me.",
@@ -680,13 +695,16 @@ def _sidecar_call(path: str, body: Dict[str, Any]) -> Dict[str, Any]:
         method="POST",
     )
     try:
-        with urllib.request.urlopen(request, timeout=15) as response:
+        # IPC stays on loopback even when the host configures an HTTP proxy.
+        # The sidecar token must never be forwarded to that proxy.
+        opener = urllib.request.build_opener(urllib.request.ProxyHandler({}))
+        with opener.open(request, timeout=15) as response:
             raw = response.read().decode("utf-8")
             status = response.status
     except urllib.error.HTTPError as exc:
         raw = exc.read().decode("utf-8", errors="replace")
         status = exc.code
-    except urllib.error.URLError as exc:
+    except (OSError, http.client.HTTPException) as exc:
         raise InlineToolError(f"Inline sidecar is not reachable: {exc}", "transient") from exc
 
     try: