gobby 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

gobby/mcp_proxy/tools/agent_messaging.py

@@ -6,9 +6,10 @@ Provides messaging capabilities between parent and child sessions:
 - send_to_child: Parent sends message to a specific child
 - poll_messages: Check for incoming messages
 - mark_message_read: Mark a message as read
-- broadcast_to_children: Send message to all running children
+- broadcast_to_children: Send message to all children (active in database)
 
-These tools resolve session relationships from RunningAgentRegistry.
+These tools resolve session relationships from the database (LocalSessionManager),
+which is the authoritative source for parent_session_id relationships.
 """
 
 from __future__ import annotations
@@ -17,9 +18,9 @@ import logging
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
-    from gobby.agents.registry import RunningAgentRegistry
     from gobby.mcp_proxy.tools.internal import InternalToolRegistry
     from gobby.storage.inter_session_messages import InterSessionMessageManager
+    from gobby.storage.sessions import LocalSessionManager
 
 logger = logging.getLogger(__name__)
 
@@ -27,7 +28,7 @@ logger = logging.getLogger(__name__)
 def add_messaging_tools(
     registry: InternalToolRegistry,
     message_manager: InterSessionMessageManager,
-    agent_registry: RunningAgentRegistry,
+    session_manager: LocalSessionManager,
 ) -> None:
     """
     Add inter-agent messaging tools to an existing registry.
@@ -35,12 +36,20 @@ def add_messaging_tools(
     Args:
         registry: The InternalToolRegistry to add tools to (typically gobby-agents)
         message_manager: InterSessionMessageManager for persisting messages
-        agent_registry: RunningAgentRegistry for resolving parent/child relationships
+        session_manager: LocalSessionManager for resolving parent/child relationships
+            (database is the authoritative source for session relationships)
     """
+    from gobby.utils.project_context import get_project_context
+
+    def _resolve_session_id(ref: str) -> str:
+        """Resolve session reference (#N, N, UUID, or prefix) to UUID."""
+        project_ctx = get_project_context()
+        project_id = project_ctx.get("id") if project_ctx else None
+        return session_manager.resolve_session_reference(ref, project_id)
 
     @registry.tool(
         name="send_to_parent",
-        description="Send a message from a child session to its parent session.",
+        description="Send a message from a child session to its parent session. Accepts #N, N, UUID, or prefix for session_id.",
     )
     async def send_to_parent(
         session_id: str,
@@ -54,7 +63,7 @@ def add_messaging_tools(
         or requests back to its parent session.
 
         Args:
-            session_id: The current (child) session ID
+            session_id: Session reference (accepts #N, N, UUID, or prefix) for the current (child) session
             content: Message content to send
             priority: Message priority ("normal" or "urgent")
 
@@ -62,30 +71,41 @@ def add_messaging_tools(
             Dict with success status and message details
         """
         try:
-            # Find the running agent to get parent relationship
-            agent = agent_registry.get_by_session(session_id)
-            if not agent:
+            # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+            try:
+                resolved_session_id = _resolve_session_id(session_id)
+            except ValueError as e:
+                return {"success": False, "error": str(e)}
+
+            # Look up session in database (authoritative source for relationships)
+            session = session_manager.get(resolved_session_id)
+            if not session:
                 return {
                     "success": False,
-                    "error": f"Session {session_id} not found in running agent registry",
+                    "error": f"Session {resolved_session_id} not found",
                 }
 
-            parent_session_id = agent.parent_session_id
+            parent_session_id = session.parent_session_id
             if not parent_session_id:
                 return {
                     "success": False,
-                    "error": "No parent session found for this agent",
+                    "error": "No parent session for this session",
                 }
 
             # Create the message
             msg = message_manager.create_message(
-                from_session=session_id,
+                from_session=resolved_session_id,
                 to_session=parent_session_id,
                 content=content,
                 priority=priority,
             )
 
-            logger.info(f"Message sent from {session_id} to parent {parent_session_id}: {msg.id}")
+            logger.info(
+                "Message sent from %s to parent %s: %s",
+                resolved_session_id,
+                parent_session_id,
+                msg.id,
+            )
 
             return {
                 "success": True,
@@ -94,7 +114,7 @@ def add_messaging_tools(
             }
 
         except Exception as e:
-            logger.error(f"Failed to send message to parent: {e}")
+            logger.error("Failed to send message to parent: %s", e)
             return {
                 "success": False,
                 "error": str(e),
@@ -102,7 +122,7 @@ def add_messaging_tools(
 
     @registry.tool(
         name="send_to_child",
-        description="Send a message from a parent session to a specific child session.",
+        description="Send a message from a parent session to a specific child session. Accepts #N, N, UUID, or prefix for session IDs.",
     )
     async def send_to_child(
         parent_session_id: str,
@@ -117,8 +137,8 @@ def add_messaging_tools(
         updates, or coordination messages to a spawned child.
 
         Args:
-            parent_session_id: The parent session ID (sender)
-            child_session_id: The child session ID (recipient)
+            parent_session_id: Session reference (accepts #N, N, UUID, or prefix) for the parent (sender)
+            child_session_id: Session reference (accepts #N, N, UUID, or prefix) for the child (recipient)
             content: Message content to send
             priority: Message priority ("normal" or "urgent")
 
@@ -126,33 +146,43 @@ def add_messaging_tools(
             Dict with success status and message details
         """
         try:
-            # Verify the child exists and belongs to this parent
-            child_agent = agent_registry.get_by_session(child_session_id)
-            if not child_agent:
+            # Resolve session IDs to UUIDs (accepts #N, N, UUID, or prefix)
+            try:
+                resolved_parent_id = _resolve_session_id(parent_session_id)
+                resolved_child_id = _resolve_session_id(child_session_id)
+            except ValueError as e:
+                return {"success": False, "error": str(e)}
+
+            # Verify the child exists in database and belongs to this parent
+            child_session = session_manager.get(resolved_child_id)
+            if not child_session:
                 return {
                     "success": False,
-                    "error": f"Child session {child_session_id} not found in running agent registry",
+                    "error": f"Child session {resolved_child_id} not found",
                 }
 
-            if child_agent.parent_session_id != parent_session_id:
+            if child_session.parent_session_id != resolved_parent_id:
                 return {
                     "success": False,
                     "error": (
-                        f"Session {child_session_id} is not a child of {parent_session_id}. "
-                        f"Actual parent: {child_agent.parent_session_id}"
+                        f"Session {resolved_child_id} is not a child of {resolved_parent_id}. "
+                        f"Actual parent: {child_session.parent_session_id}"
                     ),
                 }
 
             # Create the message
             msg = message_manager.create_message(
-                from_session=parent_session_id,
-                to_session=child_session_id,
+                from_session=resolved_parent_id,
+                to_session=resolved_child_id,
                 content=content,
                 priority=priority,
             )
 
             logger.info(
-                f"Message sent from {parent_session_id} to child {child_session_id}: {msg.id}"
+                "Message sent from %s to child %s: %s",
+                resolved_parent_id,
+                resolved_child_id,
+                msg.id,
             )
 
             return {
@@ -161,7 +191,7 @@ def add_messaging_tools(
             }
 
         except Exception as e:
-            logger.error(f"Failed to send message to child: {e}")
+            logger.error("Failed to send message to child: %s", e)
             return {
                 "success": False,
                 "error": str(e),
@@ -169,7 +199,7 @@ def add_messaging_tools(
 
     @registry.tool(
         name="poll_messages",
-        description="Poll for messages sent to this session.",
+        description="Poll for messages sent to this session. Accepts #N, N, UUID, or prefix for session_id.",
     )
     async def poll_messages(
         session_id: str,
@@ -182,15 +212,21 @@ def add_messaging_tools(
         By default, returns only unread messages.
 
         Args:
-            session_id: The session ID to check messages for
+            session_id: Session reference (accepts #N, N, UUID, or prefix) to check messages for
             unread_only: If True, only return unread messages (default: True)
 
         Returns:
             Dict with success status and list of messages
         """
         try:
+            # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+            try:
+                resolved_session_id = _resolve_session_id(session_id)
+            except ValueError as e:
+                return {"success": False, "error": str(e)}
+
             messages = message_manager.get_messages(
-                to_session=session_id,
+                to_session=resolved_session_id,
                 unread_only=unread_only,
             )
 
@@ -248,7 +284,7 @@ def add_messaging_tools(
 
     @registry.tool(
         name="broadcast_to_children",
-        description="Broadcast a message to all running child sessions.",
+        description="Broadcast a message to all active child sessions. Accepts #N, N, UUID, or prefix for session_id.",
     )
     async def broadcast_to_children(
         parent_session_id: str,
@@ -256,13 +292,14 @@ def add_messaging_tools(
         priority: str = "normal",
     ) -> dict[str, Any]:
         """
-        Broadcast a message to all running children.
+        Broadcast a message to all active children.
 
-        Send the same message to all child sessions spawned by this parent.
+        Send the same message to all child sessions spawned by this parent
+        that are currently active in the database.
         Useful for coordination or shutdown signals.
 
         Args:
-            parent_session_id: The parent session ID
+            parent_session_id: Session reference (accepts #N, N, UUID, or prefix) for the parent
             content: Message content to broadcast
             priority: Message priority ("normal" or "urgent")
 
@@ -270,13 +307,22 @@ def add_messaging_tools(
             Dict with success status and count of messages sent
         """
         try:
-            children = agent_registry.list_by_parent(parent_session_id)
+            # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+            try:
+                resolved_parent_id = _resolve_session_id(parent_session_id)
+            except ValueError as e:
+                return {"success": False, "error": str(e)}
+
+            # Get all children from database
+            all_children = session_manager.find_children(resolved_parent_id)
+            # Filter to active children only
+            children = [c for c in all_children if c.status == "active"]
 
             if not children:
                 return {
                     "success": True,
                     "sent_count": 0,
-                    "message": "No running children found",
+                    "message": "No active children found",
                 }
 
             sent_count = 0
@@ -285,14 +331,14 @@ def add_messaging_tools(
             for child in children:
                 try:
                     message_manager.create_message(
-                        from_session=parent_session_id,
-                        to_session=child.session_id,
+                        from_session=resolved_parent_id,
+                        to_session=child.id,
                         content=content,
                         priority=priority,
                     )
                     sent_count += 1
                 except Exception as e:
-                    errors.append(f"{child.session_id}: {e}")
+                    errors.append(f"{child.id}: {e}")
 
             result: dict[str, Any] = {
                 "success": True,
@@ -304,13 +350,16 @@ def add_messaging_tools(
                 result["errors"] = errors
 
             logger.info(
-                f"Broadcast from {parent_session_id} sent to {sent_count}/{len(children)} children"
+                "Broadcast from %s sent to %d/%d children",
+                resolved_parent_id,
+                sent_count,
+                len(children),
             )
 
             return result
 
         except Exception as e:
-            logger.error(f"Failed to broadcast to children: {e}")
+            logger.error("Failed to broadcast to children: %s", e)
             return {
                 "success": False,
                 "error": str(e),