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

package/plugin/inline/tools.py

@@ -88,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:
@@ -108,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 "",
     }
 
@@ -243,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,8 +270,9 @@ INLINE_TOOL_SCHEMA = {
         + "\n\n"
         "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. "
+        "To hand work to another bot, mention it in your normal reply; its answer comes back to you as a turn that doesn't need a response, and asking it again takes a new mention. "
         "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. "
@@ -616,11 +622,20 @@ def _set_reply_threads(args: Dict[str, Any]) -> Dict[str, Any]:
     turn = _current_turn()
     if not turn.get("senderId"):
         raise InlineToolError("Only the person who asked can change reply threads, and this turn has no sender", "forbidden")
+    parent_chat_id = turn.get("parentChatId") or ""
+    chat_type = turn.get("chatType") or "group"
+    if parent_chat_id:
+        # The change lands on the parent, so the parent's own type decides who may make it:
+        # someone added to a thread under a DM is in a group here but not in that DM.
+        parent = _sidecar_call("/chat", {"target": {"chatId": parent_chat_id}}).get("result")
+        if not isinstance(parent, dict) or not parent:
+            raise InlineToolError("parent chat access could not be confirmed", "forbidden")
+        chat_type = owner.chat_type_from_info(parent)
     try:
         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")),
+            chat_type=chat_type,
+            parent_chat_id=parent_chat_id,
             actor_id=turn["senderId"],
             actor_is_bot=bool(turn.get("senderIsBot")),
             mode=mode,
@@ -647,9 +662,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.",