zyndai-agent 0.1.5__py3-none-any.whl → 0.2.2__py3-none-any.whl

zyndai_agent/search.py

@@ -1,6 +1,7 @@
 # Agent Discovery and Search Protocol Module for ZyndAI
 import logging
 import requests
+from urllib.parse import urlencode
 
 from typing import List, Optional, TypedDict
 
@@ -11,53 +12,174 @@ logging.basicConfig(
 )
 logger = logging.getLogger("SearchAndDiscovery")
 
+
 class AgentSearchResponse(TypedDict):
     id: str
     name: str
     description: str
-    mqttUri: Optional[str]
+    mqttUri: Optional[str]  # Deprecated, kept for backward compatibility
+    httpWebhookUrl: Optional[str]  # Field for webhook communication
     inboxTopic: Optional[str]
-    matchScore: int
+    capabilities: Optional[dict]
+    status: Optional[str]
     didIdentifier: str
-    did: dict
+    did: str  # JSON string of DID credential
+
 
 class SearchAndDiscoveryManager:
     """
     This class implements the search and discovery protocol for ZyndAI agents.
     It allows agents to discover each other and share information about their capabilities.
-    """
 
-    def __init__(self, registry_url: str = "http://localhost:3002/sdk/search"):
+    The search uses semantic matching via the keyword parameter, allowing for
+    fuzzy/vague searches across agent names, descriptions, and capabilities.
+    """
 
+    def __init__(self, registry_url: str = "http://localhost:3002"):
         self.agents = []
         self.registry_url = registry_url
 
+    def search_agents(
+        self,
+        keyword: Optional[str] = None,
+        name: Optional[str] = None,
+        capabilities: Optional[List[str]] = None,
+        status: Optional[str] = None,
+        did: Optional[str] = None,
+        limit: int = 10,
+        offset: int = 0
+    ) -> List[AgentSearchResponse]:
+        """
+        Search for agents in the registry using various filters.
+
+        The keyword parameter supports semantic search across name, description,
+        capabilities, and metadata fields.
+
+        Args:
+            keyword: Semantic search term (searches across name, description, capabilities, metadata)
+            name: Filter by agent name (case-insensitive, partial match)
+            capabilities: List of capabilities to filter by
+            status: Filter by agent status (e.g., "ACTIVE")
+            did: Filter by exact DID match
+            limit: Maximum number of results to return (default: 10, max: 100)
+            offset: Number of results to skip for pagination (default: 0)
+
+        Returns:
+            List of matching agents
+        """
+        logger.info(f"Searching agents with keyword='{keyword}', capabilities={capabilities}")
+
+        # Build query parameters
+        params = {}
+
+        if keyword:
+            params["keyword"] = keyword
+        if name:
+            params["name"] = name
+        if capabilities:
+            params["capabilities"] = ",".join(capabilities)
+        if status:
+            params["status"] = status
+        if did:
+            params["did"] = did
+
+        params["limit"] = limit
+        params["offset"] = offset
+
+        try:
+            url = f"{self.registry_url}/agents"
+            logger.info(f"GET {url}?{urlencode(params)}")
+
+            resp = requests.get(url, params=params)
+
+            if resp.status_code == 200:
+                response_data = resp.json()
+                # API returns { data: [...], count: N, total: N }
+                agents = response_data.get("data", [])
+                total = response_data.get("total", len(agents))
+                logger.info(f"Found {len(agents)} agents (total: {total}).")
+                return agents
+            else:
+                logger.error(f"Failed to search agents: {resp.status_code} - {resp.text}")
+                return []
+
+        except requests.RequestException as e:
+            logger.error(f"Request failed: {e}")
+            return []
+
+    def search_agents_by_capabilities(
+        self,
+        capabilities: List[str] = [],
+        top_k: Optional[int] = None
+    ) -> List[AgentSearchResponse]:
+        """
+        Discover agents based on capabilities using semantic keyword search.
+
+        This method converts capabilities into a keyword search query for
+        semantic matching across the registry.
 
-    def search_agents_by_capabilities(self, capabilities: List[str] = [], match_score_gte: float = 0.5, top_k: Optional[int] = None) -> List[AgentSearchResponse]:
+        Args:
+            capabilities: List of capability terms to search for
+            top_k: Maximum number of results to return
+
+        Returns:
+            List of matching agents
         """
-        Discover all registered agents in the system based on their capabilities.
+        logger.info(f"Discovering agents by capabilities: {capabilities}")
+
+        # Convert capabilities list into a semantic search keyword
+        # Join capabilities into a search phrase for semantic matching
+        keyword = " ".join(capabilities) if capabilities else None
+
+        limit = top_k if top_k is not None else 10
+
+        return self.search_agents(
+            keyword=keyword,
+            limit=limit
+        )
 
-        match_score_gte: Minimum match score for agents to be included in the results.
-        top_k: Optional parameter to limit the number of results returned or return all.
+    def search_agents_by_keyword(
+        self,
+        keyword: str,
+        limit: int = 10,
+        offset: int = 0
+    ) -> List[AgentSearchResponse]:
         """
+        Search for agents using a semantic keyword search.
 
-        logger.info("Discovering agents...")
+        The keyword is matched against agent name, description, capabilities,
+        and metadata using semantic search.
 
+        Args:
+            keyword: Search term for semantic matching
+            limit: Maximum number of results (default: 10)
+            offset: Pagination offset (default: 0)
 
-        resp = requests.post(f"{self.registry_url}/sdk/search", json={"userProvidedCapabilities": capabilities})
-        if resp.status_code == 201:
-            agents = resp.json()
-            logger.info(f"Discovered {len(agents)} agents.")
+        Returns:
+            List of matching agents
+        """
+        return self.search_agents(keyword=keyword, limit=limit, offset=offset)
 
-            filtered_agents = [
-                agent for agent in agents
-                if agent.get("matchScore", 0) >= match_score_gte
-            ]
+    def get_agent_by_id(self, agent_id: str) -> Optional[AgentSearchResponse]:
+        """
+        Get a specific agent by its ID.
 
-            if top_k is not None:
-                filtered_agents = filtered_agents[:top_k]
+        Args:
+            agent_id: The unique identifier of the agent
 
-            return filtered_agents
-        else:
-            logger.error(f"Failed to discover agents: {resp.status_code} - {resp.text}")
-            return []
+        Returns:
+            Agent details or None if not found
+        """
+        try:
+            url = f"{self.registry_url}/agents/{agent_id}"
+            resp = requests.get(url)
+
+            if resp.status_code == 200:
+                return resp.json()
+            else:
+                logger.error(f"Failed to get agent {agent_id}: {resp.status_code}")
+                return None
+
+        except requests.RequestException as e:
+            logger.error(f"Request failed: {e}")
+            return None

zyndai_agent/webhook_communication.py

@@ -0,0 +1,470 @@
+import time
+import logging
+import threading
+import requests
+from flask import Flask, request, jsonify
+from typing import List, Callable, Optional, Dict, Any
+from zyndai_agent.message import AgentMessage
+from zyndai_agent.search import AgentSearchResponse
+from x402.flask.middleware import PaymentMiddleware
+
+# Configure logging with a more descriptive format
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger("WebhookAgentCommunication")
+
+
+class WebhookCommunicationManager:
+    """
+    HTTP Webhook-based communication manager for LangChain agents.
+
+    This class provides tools for LangChain agents to communicate via HTTP webhooks,
+    enabling multi-agent collaboration through a request-response pattern.
+    Each agent runs an embedded Flask server to receive messages.
+    """
+
+    identity_credential: dict = None
+
+    def __init__(
+        self,
+        agent_id: str,
+        webhook_host: str = "0.0.0.0",
+        webhook_port: int = 5000,
+        webhook_url: Optional[str] = None,
+        auto_restart: bool = True,
+        message_history_limit: int = 100,
+        identity_credential: dict = None,
+        price: Optional[str] = "$0.01",
+        pay_to_address: Optional[str] = None
+    ):
+        """
+        Initialize the webhook agent communication manager.
+
+        Args:
+            agent_id: Unique identifier for this agent
+            webhook_host: Host address to bind the webhook server (default: 0.0.0.0)
+            webhook_port: Port number for the webhook server (default: 5000)
+            webhook_url: Public webhook URL (auto-generated if None)
+            auto_restart: Whether to attempt restart on failure
+            message_history_limit: Maximum number of messages to keep in history
+            identity_credential: DID credential for this agent
+        """
+
+        self.agent_id = agent_id
+        self.webhook_host = webhook_host
+        self.webhook_port = webhook_port
+        self.webhook_url = webhook_url
+        self.auto_restart = auto_restart
+        self.message_history_limit = message_history_limit
+
+        self.identity_credential = identity_credential
+
+        self.is_running = False
+        self.is_agent_connected = False
+        self.received_messages = []
+        self.message_history = []
+        self.message_handlers = []
+        self.target_webhook_url = None
+        self.pending_responses = {}  # Store responses by message_id
+
+        # Thread safety
+        self._lock = threading.Lock()
+
+        # Create Flask app
+        self.flask_app = Flask(f"agent_{agent_id}")
+        self.flask_app.logger.setLevel(logging.ERROR)  # Suppress Flask logging
+
+        if price != None and pay_to_address != None:
+            self.payment_middleware = PaymentMiddleware(self.flask_app)
+            self.payment_middleware.add(
+                price,
+                pay_to_address,
+                path="/webhook"
+            )
+        else:
+            print("Disabling x402, X402 payment config not provided")
+
+        self._setup_routes()
+
+        # Start webhook server
+        self.start_webhook_server()
+
+        print("Agent webhook server started")
+        print(f"Listening on {self.webhook_url}")
+
+    def _setup_routes(self):
+        """Setup Flask routes for webhook endpoints."""
+
+        @self.flask_app.route('/webhook', methods=['POST'])
+        def webhook_handler():
+            return self._handle_webhook_request(sync=False)
+
+        @self.flask_app.route('/webhook/sync', methods=['POST'])
+        def webhook_sync_handler():
+            return self._handle_webhook_request(sync=True)
+
+        @self.flask_app.route('/health', methods=['GET'])
+        def health_check():
+            return jsonify({
+                "status": "ok",
+                "agent_id": self.agent_id,
+                "timestamp": time.time()
+            }), 200
+
+    def _handle_webhook_request(self, sync=False):
+        """Handle incoming webhook POST requests."""
+        try:
+            # Verify request is JSON
+            if not request.is_json:
+                logger.error("Received non-JSON request")
+                return jsonify({"error": "Content-Type must be application/json"}), 400
+
+            payload = request.get_json()
+
+            # Parse message from dict (request.get_json() returns a dict, not a string)
+            message = AgentMessage.from_dict(payload)
+
+            logger.info(f"[{self.agent_id}] Received message from {message.sender_id}")
+
+            # Auto-connect to sender if not connected
+            if not self.is_agent_connected:
+                self.is_agent_connected = True
+
+            # Store in history
+            message_with_metadata = {
+                "message": message,
+                "received_at": time.time(),
+                "structured": True,
+                "source_ip": request.remote_addr
+            }
+
+            print("\nIncoming Message: ", message.content, "\n")
+
+            with self._lock:
+                self.received_messages.append(message_with_metadata)
+                self.message_history.append(message_with_metadata)
+
+                # Maintain history limit
+                if len(self.message_history) > self.message_history_limit:
+                    self.message_history = self.message_history[-self.message_history_limit:]
+
+            # Check if synchronous response is requested
+            if sync:
+                # Wait for handler to process and store response
+                # Invoke message handlers synchronously
+                for handler in self.message_handlers:
+                    try:
+                        handler(message, None)  # No topic in webhook context
+                    except Exception as e:
+                        logger.error(f"Error in message handler: {e}")
+
+                # Wait for response (with timeout)
+                timeout = 30  # 30 seconds
+                start_time = time.time()
+                while time.time() - start_time < timeout:
+                    with self._lock:
+                        if message.message_id in self.pending_responses:
+                            response = self.pending_responses.pop(message.message_id)
+                            return jsonify({
+                                "status": "success",
+                                "message_id": message.message_id,
+                                "response": response,
+                                "timestamp": time.time()
+                            }), 200
+                    time.sleep(0.1)  # Small delay to avoid busy waiting
+
+                # Timeout - no response received
+                return jsonify({
+                    "status": "timeout",
+                    "message_id": message.message_id,
+                    "error": "Agent did not respond within timeout period",
+                    "timestamp": time.time()
+                }), 408
+            else:
+                # Async mode - invoke handlers and return immediately
+                for handler in self.message_handlers:
+                    try:
+                        handler(message, None)  # No topic in webhook context
+                    except Exception as e:
+                        logger.error(f"Error in message handler: {e}")
+
+                # Return success
+                return jsonify({
+                    "status": "received",
+                    "message_id": message.message_id,
+                    "timestamp": time.time()
+                }), 200
+
+        except Exception as e:
+            logger.error(f"Error handling webhook request: {e}")
+            return jsonify({"error": str(e)}), 500
+
+    def start_webhook_server(self):
+        """Start Flask webhook server in background thread."""
+        if self.is_running:
+            logger.warning("Webhook server already running")
+            return
+
+        # Try to bind to configured port, retry with different ports if needed
+        max_retries = 10
+        server_started = False
+
+        for attempt in range(max_retries):
+            try:
+                port = self.webhook_port + attempt
+
+                def run_flask():
+                    self.flask_app.run(
+                        host=self.webhook_host,
+                        port=port,
+                        debug=False,
+                        use_reloader=False,
+                        threaded=True
+                    )
+
+                self.flask_thread = threading.Thread(
+                    target=run_flask,
+                    daemon=True,
+                    name=f"WebhookServer-{self.agent_id}"
+                )
+                self.flask_thread.start()
+
+                # Update actual port used
+                self.webhook_port = port
+
+                # Auto-form webhook URL from host and port
+                if self.webhook_url is None:
+                    host = "localhost" if self.webhook_host == "0.0.0.0" else self.webhook_host
+                    scheme = "https" if port == 443 else "http"
+                    self.webhook_url = f"{scheme}://{host}:{port}/webhook"
+
+                self.is_running = True
+                server_started = True
+
+                # Wait for server to start
+                time.sleep(1.5)
+
+                logger.info(f"Webhook server started on {self.webhook_host}:{port}")
+                break
+
+            except OSError as e:
+                if "Address already in use" in str(e) and attempt < max_retries - 1:
+                    logger.warning(f"Port {port} already in use, trying next port...")
+                    continue
+                else:
+                    logger.error(f"Failed to start webhook server: {e}")
+                    raise
+
+        if not server_started:
+            raise RuntimeError("Failed to start webhook server after multiple attempts")
+
+    def stop_webhook_server(self):
+        """Stop the webhook server and cleanup resources."""
+        if not self.is_running:
+            logger.warning("Webhook server not running")
+            return
+
+        self.is_running = False
+        logger.info(f"[{self.agent_id}] Webhook server stopped")
+
+    def send_message(
+        self,
+        message_content: str,
+        message_type: str = "query",
+        receiver_id: Optional[str] = None
+    ) -> str:
+        """
+        Send a message to another agent via HTTP POST.
+
+        Args:
+            message_content: The main content of the message
+            message_type: The type of message being sent
+            receiver_id: Specific recipient ID
+
+        Returns:
+            Status message or error
+        """
+        if not self.is_running:
+            return "Webhook server not running. Cannot send messages."
+
+        if not self.target_webhook_url:
+            return "No target agent connected. Use connect_agent() first."
+
+        try:
+            # Create structured message
+            message = AgentMessage(
+                content=message_content,
+                sender_id=self.agent_id,
+                receiver_id=receiver_id,
+                message_type=message_type,
+                sender_did=self.identity_credential
+            )
+
+            # Convert to dict for JSON serialization
+            # Note: use to_dict() not to_json() - json= parameter expects a dict
+            json_payload = message.to_dict()
+
+            # Send HTTP POST request with JSON body
+            response = requests.post(
+                self.target_webhook_url,
+                json=json_payload,
+                headers={"Content-Type": "application/json"},
+                timeout=30  # 30 second timeout
+            )
+
+            # Check response
+            if response.status_code == 200:
+                logger.info(f"Message sent successfully to {self.target_webhook_url}")
+
+                # Add to history
+                with self._lock:
+                    self.message_history.append({
+                        "message": message,
+                        "sent_at": time.time(),
+                        "direction": "outgoing",
+                        "target_url": self.target_webhook_url
+                    })
+
+                    if len(self.message_history) > self.message_history_limit:
+                        self.message_history = self.message_history[-self.message_history_limit:]
+
+                return f"Message sent successfully to topic '{self.target_webhook_url}'"
+            else:
+                error_msg = f"Failed to send message. HTTP {response.status_code}: {response.text}"
+                logger.error(error_msg)
+                return error_msg
+
+        except requests.exceptions.Timeout:
+            error_msg = "Error: Request timed out. Target agent may be offline."
+            logger.error(error_msg)
+            return error_msg
+        except requests.exceptions.ConnectionError:
+            error_msg = "Error: Could not connect to target agent. Agent may be offline."
+            logger.error(error_msg)
+            return error_msg
+        except Exception as e:
+            error_msg = f"Error sending message: {str(e)}"
+            logger.error(f"[{self.agent_id}] {error_msg}")
+            return error_msg
+
+    def read_messages(self) -> str:
+        """
+        Read and clear the current message queue.
+
+        Returns:
+            Formatted string of received messages
+        """
+        if not self.is_running:
+            return "Webhook server not running."
+
+        if not self.received_messages:
+            return "No new messages in the queue."
+
+        # Format messages for output
+        formatted_messages = []
+        for item in self.received_messages:
+            message = item["message"]
+
+            formatted_msg = (
+                f"From: {message.sender_id}\n"
+                f"Type: {message.message_type}\n"
+                f"Content: {message.content}\n"
+            )
+            formatted_messages.append(formatted_msg)
+
+        # Create a combined output
+        output = "Messages received:\n\n" + "\n---\n".join(formatted_messages)
+
+        # Clear the received messages queue but keep them in history
+        with self._lock:
+            self.received_messages.clear()
+
+        return output
+
+    def add_message_handler(self, handler_function: Callable) -> None:
+        """
+        Add a custom message handler function.
+
+        Args:
+            handler_function: Function to call when messages arrive
+                              Should accept (message, topic) parameters
+        """
+        with self._lock:
+            self.message_handlers.append(handler_function)
+        logger.info(f"[{self.agent_id}] Added custom message handler")
+
+    def register_handler(self, handler_fn: Callable[[AgentMessage, str], None]):
+        """Alias for add_message_handler for backward compatibility."""
+        self.add_message_handler(handler_fn)
+
+    def set_response(self, message_id: str, response: str):
+        """
+        Set a response for a specific message ID (for synchronous responses).
+
+        Args:
+            message_id: The ID of the message being responded to
+            response: The response content
+        """
+        with self._lock:
+            self.pending_responses[message_id] = response
+        logger.info(f"[{self.agent_id}] Set response for message {message_id}")
+
+    def get_connection_status(self) -> Dict[str, Any]:
+        """
+        Get the current webhook server status and statistics.
+
+        Returns:
+            Dictionary with connection information
+        """
+        return {
+            "agent_id": self.agent_id,
+            "is_running": self.is_running,
+            "webhook_url": self.webhook_url,
+            "webhook_port": self.webhook_port,
+            "target_webhook_url": self.target_webhook_url,
+            "pending_messages": len(self.received_messages),
+            "message_history_count": len(self.message_history)
+        }
+
+    def get_message_history(
+        self,
+        limit: int = None,
+        filter_by_topic: str = None
+    ) -> List[Dict[str, Any]]:
+        """
+        Get the message history with optional filtering.
+
+        Args:
+            limit: Maximum number of messages to return (None for all)
+            filter_by_topic: Only return messages from this topic (not applicable for webhooks)
+
+        Returns:
+            List of message history entries
+        """
+        with self._lock:
+            history = self.message_history.copy()
+
+        # Apply limit if specified
+        if limit is not None:
+            history = history[-limit:]
+
+        return history
+
+    def connect_agent(self, agent: AgentSearchResponse):
+        """
+        Connect to another agent using their webhook URL.
+
+        Args:
+            agent: Agent search response containing httpWebhookUrl
+        """
+        # Support both old 'webhookUrl' and new 'httpWebhookUrl' field names
+        webhook_url = agent.get("httpWebhookUrl") or agent.get("webhookUrl")
+        if not webhook_url:
+            raise ValueError("Agent does not have httpWebhookUrl. Cannot connect via webhook.")
+
+        self.target_webhook_url = webhook_url
+        self.is_agent_connected = True
+
+        logger.info(f"Connected to agent {agent.get('didIdentifier', 'unknown')} at {self.target_webhook_url}")