jarviscore-framework 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

jarviscore/orchestration/engine.py

@@ -11,6 +11,7 @@ from typing import List, Dict, Any, Optional
 from .claimer import StepClaimer
 from .dependency import DependencyManager
 from .status import StatusManager
+from jarviscore.context import create_context
 
 logger = logging.getLogger(__name__)
 
@@ -169,9 +170,9 @@ class WorkflowEngine:
                 task = step.copy()
 
                 # Inject dependency outputs as context
+                dep_outputs = {}
                 if depends_on := step.get('depends_on'):
                     dep_ids = self._resolve_dependency_ids(depends_on, normalized_steps)
-                    dep_outputs = {}
                     for dep_id in dep_ids:
                         if dep_id in self.memory:
                             dep_result = self.memory[dep_id]
@@ -179,13 +180,24 @@ class WorkflowEngine:
                             output = dep_result.get('output') if isinstance(dep_result, dict) else dep_result
                             dep_outputs[dep_id] = output
 
-                    # Add dependency outputs to task context
-                    task['context'] = {
-                        'previous_step_results': dep_outputs,
-                        'workflow_id': workflow_id,
-                        'step_id': step_id
-                    }
-                    logger.debug(f"Injected context with {len(dep_outputs)} dependencies")
+                # Add dependency outputs to task context
+                task['context'] = {
+                    'previous_step_results': dep_outputs,
+                    'workflow_id': workflow_id,
+                    'step_id': step_id
+                }
+
+                # Build and inject JarvisContext for Custom Profile agents
+                jarvis_ctx = create_context(
+                    workflow_id=workflow_id,
+                    step_id=step_id,
+                    task=task.get('task', ''),
+                    params=task.get('params', {}),
+                    memory_dict=self.memory,
+                    dependency_manager=self.dependency_manager
+                )
+                task['_jarvis_context'] = jarvis_ctx
+                logger.debug(f"Injected JarvisContext for step {step_id}")
 
                 # 6. Execute step with context
                 logger.info(f"Executing step {step_id} with agent {agent.agent_id}")

jarviscore/p2p/__init__.py

@@ -6,12 +6,16 @@ Wraps swim_p2p library for distributed agent coordination:
 - ZMQ messaging for agent communication
 - Smart keepalive with traffic suppression
 - Step output broadcasting
+- PeerClient for direct agent-to-agent communication
 """
 
 from .coordinator import P2PCoordinator
 from .swim_manager import SWIMThreadManager
 from .keepalive import P2PKeepaliveManager, CircuitState
 from .broadcaster import StepOutputBroadcaster, StepExecutionResult
+from .peer_client import PeerClient
+from .peer_tool import PeerTool
+from .messages import PeerInfo, IncomingMessage, MessageType
 
 __all__ = [
     'P2PCoordinator',
@@ -20,4 +24,10 @@ __all__ = [
     'CircuitState',
     'StepOutputBroadcaster',
     'StepExecutionResult',
+    # PeerClient API
+    'PeerClient',
+    'PeerTool',
+    'PeerInfo',
+    'IncomingMessage',
+    'MessageType',
 ]

jarviscore/p2p/coordinator.py

@@ -13,6 +13,7 @@ from typing import List, Dict, Any, Optional
 from .swim_manager import SWIMThreadManager
 from .keepalive import P2PKeepaliveManager
 from .broadcaster import StepOutputBroadcaster
+from .messages import IncomingMessage, MessageType
 
 logger = logging.getLogger(__name__)
 
@@ -61,6 +62,7 @@ class P2PCoordinator:
         # State
         self._started = False
         self._capability_map: Dict[str, List[str]] = {}  # capability -> [agent_ids]
+        self._agent_peer_clients: Dict[str, Any] = {}  # agent_id -> PeerClient
 
     async def start(self):
         """
@@ -140,6 +142,10 @@ class P2PCoordinator:
             "CAPABILITY_QUERY": self._handle_capability_query,
             "P2P_KEEPALIVE": self.keepalive_manager.handle_keepalive_received,
             "P2P_KEEPALIVE_ACK": self.keepalive_manager.handle_keepalive_ack,
+            # Peer-to-peer messaging (PeerClient)
+            "PEER_NOTIFY": self._handle_peer_notify,
+            "PEER_REQUEST": self._handle_peer_request,
+            "PEER_RESPONSE": self._handle_peer_response,
         }
 
         for msg_type, handler in message_types.items():
@@ -362,3 +368,126 @@ class P2PCoordinator:
             logger.debug(f"Responded to capability query from {sender} for {capability}")
         except Exception as e:
             logger.error(f"Error handling capability query: {e}")
+
+    # ─────────────────────────────────────────────────────────────────
+    # Peer-to-peer messaging handlers (PeerClient support)
+    # ─────────────────────────────────────────────────────────────────
+
+    def register_peer_client(self, agent_id: str, peer_client):
+        """
+        Register a PeerClient for an agent.
+
+        Called by Mesh when injecting PeerClients into agents.
+        """
+        self._agent_peer_clients[agent_id] = peer_client
+        logger.debug(f"Registered PeerClient for agent: {agent_id}")
+
+    def unregister_peer_client(self, agent_id: str):
+        """Unregister a PeerClient when agent leaves mesh."""
+        self._agent_peer_clients.pop(agent_id, None)
+        logger.debug(f"Unregistered PeerClient for agent: {agent_id}")
+
+    async def _handle_peer_notify(self, sender, message):
+        """Handle peer notification message."""
+        try:
+            payload = message.get('payload', {})
+            target = payload.get('target')
+
+            # Find target agent's PeerClient
+            target_client = self._find_peer_client_by_role_or_id(target)
+            if not target_client:
+                logger.warning(f"Peer notify: target '{target}' not found")
+                return
+
+            # Create incoming message and deliver
+            incoming = IncomingMessage(
+                sender=payload.get('sender', sender),
+                sender_node=payload.get('sender_node', sender),
+                type=MessageType.NOTIFY,
+                data=payload.get('data', {}),
+                correlation_id=payload.get('correlation_id'),
+                timestamp=payload.get('timestamp', 0)
+            )
+
+            await target_client._deliver_message(incoming)
+            logger.debug(f"Delivered peer notify to {target}")
+
+        except Exception as e:
+            logger.error(f"Error handling peer notify: {e}")
+
+    async def _handle_peer_request(self, sender, message):
+        """Handle peer request message (expects response)."""
+        try:
+            payload = message.get('payload', {})
+            target = payload.get('target')
+
+            # Find target agent's PeerClient
+            target_client = self._find_peer_client_by_role_or_id(target)
+            if not target_client:
+                logger.warning(f"Peer request: target '{target}' not found")
+                return
+
+            # Create incoming message and deliver
+            incoming = IncomingMessage(
+                sender=payload.get('sender', sender),
+                sender_node=payload.get('sender_node', sender),
+                type=MessageType.REQUEST,
+                data=payload.get('data', {}),
+                correlation_id=payload.get('correlation_id'),
+                timestamp=payload.get('timestamp', 0)
+            )
+
+            await target_client._deliver_message(incoming)
+            logger.debug(f"Delivered peer request to {target}")
+
+        except Exception as e:
+            logger.error(f"Error handling peer request: {e}")
+
+    async def _handle_peer_response(self, sender, message):
+        """Handle peer response message."""
+        try:
+            payload = message.get('payload', {})
+            target = payload.get('target')
+
+            # Find target agent's PeerClient
+            target_client = self._find_peer_client_by_role_or_id(target)
+            if not target_client:
+                logger.warning(f"Peer response: target '{target}' not found")
+                return
+
+            # Create incoming message and deliver
+            incoming = IncomingMessage(
+                sender=payload.get('sender', sender),
+                sender_node=payload.get('sender_node', sender),
+                type=MessageType.RESPONSE,
+                data=payload.get('data', {}),
+                correlation_id=payload.get('correlation_id'),
+                timestamp=payload.get('timestamp', 0)
+            )
+
+            await target_client._deliver_message(incoming)
+            logger.debug(f"Delivered peer response to {target}")
+
+        except Exception as e:
+            logger.error(f"Error handling peer response: {e}")
+
+    def _find_peer_client_by_role_or_id(self, target: str):
+        """
+        Find a PeerClient by agent role or agent_id.
+
+        Args:
+            target: Role name or agent_id
+
+        Returns:
+            PeerClient instance or None
+        """
+        # Try direct agent_id lookup
+        if target in self._agent_peer_clients:
+            return self._agent_peer_clients[target]
+
+        # Try role lookup via agents
+        for agent in self.agents:
+            if agent.role == target or agent.agent_id == target:
+                return self._agent_peer_clients.get(agent.agent_id)
+
+        return None

jarviscore/p2p/messages.py

@@ -0,0 +1,87 @@
+"""
+P2P Message Types for JarvisCore Framework
+
+Defines dataclasses for peer information and messages exchanged
+between agents via the PeerClient API.
+"""
+from dataclasses import dataclass, field
+from typing import List, Dict, Any, Optional
+from enum import Enum
+import time
+
+
+class MessageType(Enum):
+    """Types of peer-to-peer messages."""
+    NOTIFY = "notify"       # Fire-and-forget notification
+    REQUEST = "request"     # Request expecting response
+    RESPONSE = "response"   # Response to a request
+
+
+@dataclass
+class PeerInfo:
+    """
+    Information about a peer agent in the mesh.
+
+    Attributes:
+        agent_id: Unique identifier for the agent
+        role: The agent's role (e.g., "scout", "analyst")
+        capabilities: List of capabilities the agent provides
+        node_id: P2P node identifier (host:port)
+        status: Current status (alive, suspected, dead)
+    """
+    agent_id: str
+    role: str
+    capabilities: List[str]
+    node_id: str = ""
+    status: str = "alive"
+
+    def has_capability(self, capability: str) -> bool:
+        """Check if peer has a specific capability."""
+        return capability in self.capabilities
+
+
+@dataclass
+class IncomingMessage:
+    """
+    A message received from a peer agent.
+
+    Attributes:
+        sender: Agent ID or role of the sender
+        sender_node: P2P node ID of the sender
+        type: Message type (notify, request, response)
+        data: Message payload
+        correlation_id: ID linking request to response (for request-response pattern)
+        timestamp: When the message was sent
+    """
+    sender: str
+    sender_node: str
+    type: MessageType
+    data: Dict[str, Any]
+    correlation_id: Optional[str] = None
+    timestamp: float = field(default_factory=time.time)
+
+    @property
+    def is_request(self) -> bool:
+        """Check if this message expects a response."""
+        return self.type == MessageType.REQUEST
+
+    @property
+    def is_notify(self) -> bool:
+        """Check if this is a fire-and-forget notification."""
+        return self.type == MessageType.NOTIFY
+
+
+@dataclass
+class OutgoingMessage:
+    """
+    A message to be sent to a peer agent.
+
+    Used internally by PeerClient for message construction.
+    """
+    target: str              # Target agent role or ID
+    type: MessageType
+    data: Dict[str, Any]
+    correlation_id: Optional[str] = None
+    timestamp: float = field(default_factory=time.time)
+    sender: str = ""         # Filled in by PeerClient
+    sender_node: str = ""    # Filled in by PeerClient