zyndai-agent 0.1.4__py3-none-any.whl → 0.2.1__py3-none-any.whl

zyndai_agent/__init__.py

@@ -0,0 +1,20 @@
+from zyndai_agent.agent import ZyndAIAgent, AgentConfig
+from zyndai_agent.communication import AgentCommunicationManager, MQTTMessage
+from zyndai_agent.webhook_communication import WebhookCommunicationManager
+from zyndai_agent.message import AgentMessage
+from zyndai_agent.search import SearchAndDiscoveryManager, AgentSearchResponse
+from zyndai_agent.identity import IdentityManager
+from zyndai_agent.payment import X402PaymentProcessor
+
+__all__ = [
+    "ZyndAIAgent",
+    "AgentConfig",
+    "AgentCommunicationManager",
+    "WebhookCommunicationManager",
+    "MQTTMessage",
+    "AgentMessage",
+    "SearchAndDiscoveryManager",
+    "AgentSearchResponse",
+    "IdentityManager",
+    "X402PaymentProcessor",
+]

zyndai_agent/agent.py

@@ -3,6 +3,7 @@ import requests
 from zyndai_agent.search import SearchAndDiscoveryManager
 from zyndai_agent.identity import IdentityManager
 from zyndai_agent.communication import AgentCommunicationManager
+from zyndai_agent.webhook_communication import WebhookCommunicationManager
 from zyndai_agent.payment import X402PaymentProcessor
 from pydantic import BaseModel
 from typing import Optional
@@ -13,46 +14,84 @@ class AgentConfig(BaseModel):
     auto_reconnect: bool = True
     message_history_limit: int = 100
     registry_url: str = "http://localhost:3002"
-    mqtt_broker_url: str
+
+    # Webhook configuration (new)
+    webhook_host: Optional[str] = "0.0.0.0"
+    webhook_port: Optional[int] = 5000
+    webhook_url: Optional[str] = None  # Public URL if behind NAT
+    api_key: Optional[str] = None  # API key for webhook registration
+
+    # MQTT configuration (deprecated, kept for backward compatibility)
+    mqtt_broker_url: Optional[str] = None
+    default_outbox_topic: Optional[str] = None
+
+    # Common configuration
     identity_credential_path: str
     identity_credential: Optional[dict] = None
-    default_outbox_topic: Optional[str] = None
     secret_seed: str = None
+    agent_id: str = None
 
-class ZyndAIAgent(SearchAndDiscoveryManager, IdentityManager, AgentCommunicationManager, X402PaymentProcessor):
+    price: Optional[str] = None
+    pay_to_address: Optional[str] = None
 
-    def __init__(self, agent_config: AgentConfig): 
+class ZyndAIAgent(SearchAndDiscoveryManager, IdentityManager, X402PaymentProcessor, WebhookCommunicationManager):
+
+    def __init__(self, agent_config: AgentConfig):
 
         self.agent_executor: CompiledStateGraph = None
-        self.agent_config = agent_config 
+        self.agent_config = agent_config
         self.x402_processor = X402PaymentProcessor(agent_config.secret_seed)
+        self.communication_mode = None  # Track which mode is active
 
         try:
             with open(agent_config.identity_credential_path, "r") as f:
                 self.identity_credential = json.load(f)
         except FileNotFoundError:
             raise FileNotFoundError(f"Identity credential file not found at {agent_config.identity_credential_path}")
-        
-        IdentityManager.__init__(self,agent_config.registry_url)
+
+        IdentityManager.__init__(self, agent_config.registry_url)
 
         SearchAndDiscoveryManager.__init__(
             self,
             registry_url=agent_config.registry_url
         )
-        
-        AgentCommunicationManager.__init__(
-            self,
-            self.identity_credential["issuer"],
-            default_inbox_topic=f"{self.identity_credential['issuer']}/inbox",
-            default_outbox_topic=agent_config.default_outbox_topic,
-            auto_reconnect=True,
-            message_history_limit=agent_config.message_history_limit,
-            identity_credential=self.identity_credential,
-            secret_seed=agent_config.secret_seed,
-            mqtt_broker_url=agent_config.mqtt_broker_url
-        )
 
-        self.update_agent_mqtt_info()
+        # Determine communication mode: webhook or MQTT
+        # Prefer webhook if webhook_port is configured
+        if agent_config.webhook_port is not None and agent_config.mqtt_broker_url is None:
+            # Use webhook mode
+            self.communication_mode = "webhook"
+            WebhookCommunicationManager.__init__(
+                self,
+                agent_id=self.identity_credential["issuer"],
+                webhook_host=agent_config.webhook_host,
+                webhook_port=agent_config.webhook_port,
+                webhook_url=agent_config.webhook_url,
+                auto_restart=agent_config.auto_reconnect,
+                message_history_limit=agent_config.message_history_limit,
+                identity_credential=self.identity_credential,
+                price=agent_config.price,
+                pay_to_address=agent_config.pay_to_address
+            )
+            self.update_agent_webhook_info()
+
+        elif agent_config.mqtt_broker_url is not None:
+            # Use MQTT mode (backward compatibility)
+            self.communication_mode = "mqtt"
+            AgentCommunicationManager.__init__(
+                self,
+                self.identity_credential["issuer"],
+                default_inbox_topic=f"{self.identity_credential['issuer']}/inbox",
+                default_outbox_topic=agent_config.default_outbox_topic,
+                auto_reconnect=True,
+                message_history_limit=agent_config.message_history_limit,
+                identity_credential=self.identity_credential,
+                secret_seed=agent_config.secret_seed,
+                mqtt_broker_url=agent_config.mqtt_broker_url
+            )
+            self.update_agent_mqtt_info()
+        else:
+            raise ValueError("Either webhook_port or mqtt_broker_url must be configured")
 
 
 
@@ -62,16 +101,53 @@ class ZyndAIAgent(SearchAndDiscoveryManager, IdentityManager, AgentCommunication
 
     def update_agent_mqtt_info(self):
         """Updates the mqtt connection info of the agent into the registry so other agents can find me"""
-        print(self.agent_config.secret_seed, self.agent_config.mqtt_broker_url, f"{self.agent_config.registry_url}/agents/update-mqtt")
-        updateResponse = requests.post(
-            f"{self.agent_config.registry_url}/agents/update-mqtt", 
+
+        updateResponse = requests.patch(
+            f"{self.agent_config.registry_url}/agents/update-mqtt",
             data={
                 "seed": self.agent_config.secret_seed,
                 "mqttUri": self.agent_config.mqtt_broker_url
             }
         )
-        print(updateResponse.status_code,"====")
+
         if (updateResponse.status_code != 201):
             raise Exception("Failed to update agent connection info in p3 registry.")
 
-        print("Synced with the registry...")
+        print("Synced with the registry...")
+
+    def update_agent_webhook_info(self):
+        """Updates the webhook URL of the agent into the registry so other agents can find me"""
+        if not self.agent_config.api_key:
+            raise ValueError("API key is required for webhook registration. Please provide api_key in AgentConfig.")
+
+        # Prepare headers with API key
+        headers = {
+            "X-API-KEY": self.agent_config.api_key,
+            "Content-Type": "application/json"
+        }
+
+        # Prepare request body
+        payload = {
+            "agentId": self.agent_config.agent_id,
+            "httpWebhookUrl": self.webhook_url
+        }
+
+        updateResponse = requests.patch(
+            f"{self.agent_config.registry_url}/agents/update-webhook",
+            json=payload,
+            headers=headers
+        )
+
+        if updateResponse.status_code != 200:
+            raise Exception(f"Failed to update agent webhook info in Zynd registry. Status: {updateResponse.status_code}, Response: {updateResponse.text}")
+
+        print("Synced webhook URL with the registry...")
+
+    def update_agent_connection_info(self):
+        """Updates the agent connection info (webhook or MQTT) in the registry based on communication mode"""
+        if self.communication_mode == "webhook":
+            self.update_agent_webhook_info()
+        elif self.communication_mode == "mqtt":
+            self.update_agent_mqtt_info()
+        else:
+            raise ValueError(f"Unknown communication mode: {self.communication_mode}")

zyndai_agent/message.py

@@ -0,0 +1,111 @@
+import time
+import json
+import uuid
+import logging
+from typing import Optional, Dict, Any
+
+logger = logging.getLogger(__name__)
+
+class AgentMessage:
+    """
+    Structured message format for agent communication.
+
+    This class provides a standardized way to format, serialize, and deserialize
+    messages exchanged between agents, with support for conversation threading,
+    message types, and metadata.
+
+    Protocol-agnostic: Can be used with MQTT, HTTP webhooks, or other transports.
+    """
+
+    def __init__(
+        self,
+        content: str,
+        sender_id: str,
+        sender_did: dict = None,
+        receiver_id: Optional[str] = None,
+        message_type: str = "query",
+        message_id: Optional[str] = None,
+        conversation_id: Optional[str] = None,
+        in_reply_to: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Initialize a new agent message.
+
+        Args:
+            content: The main message content
+            sender_id: Identifier for the message sender
+            sender_did: DID credential of the sender
+            receiver_id: Identifier for the intended recipient (None for broadcasts)
+            message_type: Type categorization ("query", "response", "broadcast", "system")
+            message_id: Unique identifier for this message (auto-generated if None)
+            conversation_id: ID grouping related messages (auto-generated if None)
+            in_reply_to: ID of the message this is responding to (None if not a reply)
+            metadata: Additional contextual information
+        """
+        self.content = content
+        self.sender_id = sender_id
+        self.receiver_id = receiver_id
+        self.sender_did = sender_did
+        self.message_type = message_type
+        self.message_id = message_id or str(uuid.uuid4())
+        self.conversation_id = conversation_id or str(uuid.uuid4())
+        self.in_reply_to = in_reply_to
+        self.metadata = metadata or {}
+        self.timestamp = time.time()
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert message to dictionary format."""
+        return {
+            "content": self.content,
+            "sender_id": self.sender_id,
+            "sender_did": self.sender_did,
+            "receiver_id": self.receiver_id,
+            "message_type": self.message_type,
+            "message_id": self.message_id,
+            "conversation_id": self.conversation_id,
+            "in_reply_to": self.in_reply_to,
+            "metadata": self.metadata,
+            "timestamp": self.timestamp
+        }
+
+    def to_json(self) -> str:
+        """Convert message to JSON string for transmission."""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'AgentMessage':
+        """Create message object from dictionary data."""
+        return cls(
+            content=data.get("content", ""),
+            sender_id=data.get("sender_id", "unknown"),
+            sender_did=data.get("sender_did", "unknown"),
+            receiver_id=data.get("receiver_id"),
+            message_type=data.get("message_type", "query"),
+            message_id=data.get("message_id"),
+            conversation_id=data.get("conversation_id"),
+            in_reply_to=data.get("in_reply_to"),
+            metadata=data.get("metadata", {})
+        )
+
+    @classmethod
+    def from_json(cls, json_str: str) -> 'AgentMessage':
+        """
+        Create message object from JSON string.
+
+        Handles both valid JSON and fallback for plain text messages.
+        """
+        try:
+            data = json.loads(json_str)
+            return cls.from_dict(data)
+        except json.JSONDecodeError as e:
+            logger.error(f"Failed to parse message as JSON: {e}")
+            return cls(
+                content=json_str,
+                sender_id="unknown",
+                message_type="raw"
+            )
+
+
+# Backward compatibility alias
+MQTTMessage = AgentMessage

zyndai_agent/search.py

@@ -15,7 +15,8 @@ class AgentSearchResponse(TypedDict):
     id: str
     name: str
     description: str
-    mqttUri: Optional[str]
+    mqttUri: Optional[str]  # Deprecated, kept for backward compatibility
+    webhookUrl: Optional[str]  # New field for webhook communication
     inboxTopic: Optional[str]
     matchScore: int
     didIdentifier: str

zyndai_agent/webhook_communication.py

@@ -0,0 +1,466 @@
+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
+
+                # Update webhook URL if not manually configured
+                if self.webhook_url is None:
+                    # Use localhost for local development, can be overridden
+                    self.webhook_url = f"http://localhost:{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 JSON and send directly
+            json_payload = message.to_json()
+
+            # Send HTTP POST request with plain JSON
+            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 webhookUrl
+        """
+        if "webhookUrl" not in agent:
+            raise ValueError("Agent does not have webhookUrl. Cannot connect via webhook.")
+
+        self.target_webhook_url = agent["webhookUrl"]
+        self.is_agent_connected = True
+
+        logger.info(f"Connected to agent {agent['didIdentifier']} at {self.target_webhook_url}")

{zyndai_agent-0.1.4.dist-info → zyndai_agent-0.2.1.dist-info}/METADATA

@@ -1,18 +1,18 @@
 Metadata-Version: 2.4
 Name: zyndai-agent
-Version: 0.1.4
-Summary: A Langchain and Autogen wrapper that enables agents to communicate and establish identity on the Zynd AI Network. This SDK provides three core capabilities: Identity Management, Agent Discovery & Search, and MQTT-based Communication.
+Version: 0.2.1
+Summary: A Langchain and Autogen wrapper that enables agents to communicate and establish identity on the Zynd AI Network. This SDK provides three core capabilities: Identity Management, Agent Discovery & Search, and HTTP Webhook or MQTT-based Communication.
 Author-email: Swapnil Shinde <swapnilshinde9382@gmail.com>
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Requires-Dist: base58>=2.1.1
 Requires-Dist: cryptography>=46.0.3
 Requires-Dist: eth-account>=0.13.7
-Requires-Dist: langchain<1.0.4
-Requires-Dist: langchain-core>=1.0.3
-Requires-Dist: langchain-openai>=1.0.2
+Requires-Dist: flask>=3.0.0
+Requires-Dist: langchain>=1.1.0
 Requires-Dist: paho-mqtt>=2.1.0
-Requires-Dist: x402>=0.2.1
+Requires-Dist: requests>=2.31.0
+Requires-Dist: x402==1.0.0
 
 # ZyndAI Agent SDK
 
@@ -22,7 +22,7 @@ A powerful Python SDK that enables AI agents to communicate securely and discove
 
 - 🔐 **Secure Identity Management**: Verify and manage agent identities using Polygon ID credentials
 - 🔍 **Smart Agent Discovery**: Search and discover agents based on their capabilities with ML-powered semantic matching
-- 💬 **Encrypted MQTT Communication**: End-to-end encrypted real-time messaging between agents
+- 💬 **Flexible Communication**: Choose between HTTP Webhooks or MQTT for encrypted real-time messaging between agents
 - 🤖 **LangChain Integration**: Seamlessly works with LangChain agents and any LLM
 - 💰 **x402 Micropayments**: Built-in support for pay-per-use API endpoints with automatic payment handling
 - 🌐 **Decentralized Network**: Connect to the global ZyndAI agent network
@@ -37,7 +37,7 @@ pip install zyndai-agent
 
 Or install from source:
 ```bash
-git clone https://github.com/P3-AI-Network/zyndai-agent.git
+git clone https://github.com/Zynd-AI-Network/zyndai-agent.git
 cd zyndai-agent
 pip install -r requirements.txt
 ```
@@ -46,18 +46,46 @@ pip install -r requirements.txt
 
 ### 1. Get Your Credentials
 
-1. Visit the [ZyndAI Dashboard](https://dashboard.zynd.ai) and create an agent
-2. Download your `identity_credential.json` file
-3. Copy your `secret_seed` from the dashboard
+Follow these steps to set up your agent credentials from the ZyndAI Dashboard:
+
+1. **Visit the Dashboard**
+   - Go to [dashboard.zynd.ai](https://dashboard.zynd.ai)
+   - Click "Get Started"
+
+2. **Connect Your Wallet**
+   - Connect your MetaMask wallet
+   - Ensure you're on the correct network
+
+3. **Create Your Agent**
+   - Navigate to the "Agents" section
+   - Click "Create New Agent"
+   - Fill in your agent's details (name, description, capabilities)
+   - Submit to create your agent
+
+4. **Get Your Agent Seed**
+   - After creating the agent, view your agent's details
+   - Copy the **Agent Seed** (secret seed phrase)
+   - Save this securely - you'll need it for your `.env` file
+
+5. **Download DID Credential Document**
+   - In your agent's view, go to the **Credentials** tab
+   - Copy or download the **DID Document Credential**
+   - Save this as `identity_credential.json` in your project directory
 
 ### 2. Environment Setup
 
-Create a `.env` file:
+Create a `.env` file in your project root:
 ```env
-AGENT_SEED=your_secret_seed_here
+AGENT_SEED=your_agent_seed_from_dashboard
+API_KEY=your_api_key_from_dashboard
 OPENAI_API_KEY=your_openai_api_key_here
 ```
 
+**Important Notes:**
+- Keep your `AGENT_SEED` and `identity_credential.json` secure and never commit them to version control
+- The agent seed and DID credential must match - they are cryptographically linked
+- Add both `.env` and `identity_credential.json` to your `.gitignore` file
+
 ### 3. Basic Agent Example
 ```python
 from zyndai_agent.agent import AgentConfig, ZyndAIAgent
@@ -206,7 +234,7 @@ Create LangChain tools that leverage x402-enabled paid APIs:
 ```python
 from langchain_core.tools import tool
 from langchain_openai import ChatOpenAI
-from langchain.agents import create_tool_calling_agent, AgentExecutor
+from langchain_classic.agents import create_tool_calling_agent, AgentExecutor
 from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
 from zyndai_agent.agent import AgentConfig, ZyndAIAgent
 import os
@@ -318,12 +346,37 @@ for agent in agents:
 
 ### 💬 Secure Communication
 
-All messages are end-to-end encrypted using ECIES (Elliptic Curve Integrated Encryption Scheme):
+The SDK supports two communication modes: **HTTP Webhooks** (recommended) and **MQTT** (legacy). Both provide end-to-end encryption using ECIES (Elliptic Curve Integrated Encryption Scheme).
+
+#### HTTP Webhook Mode (Recommended)
+
+Each agent runs an embedded Flask server to receive webhook requests. This mode is simpler, doesn't require external MQTT brokers, and works well for most use cases.
+
 ```python
+from zyndai_agent.agent import AgentConfig, ZyndAIAgent
+import os
+
+# Configure with webhook mode
+agent_config = AgentConfig(
+    webhook_host="0.0.0.0",  # Listen on all interfaces
+    webhook_port=5000,  # Port for webhook server
+    webhook_url=None,  # Auto-generated or specify public URL
+    api_key=os.environ["API_KEY"],  # API key for webhook registration
+    auto_reconnect=True,
+    message_history_limit=100,
+    registry_url="https://registry.zynd.ai",
+    identity_credential_path="./identity_credential.json",
+    secret_seed=os.environ["AGENT_SEED"]
+)
+
+# Agent automatically starts webhook server
+zyndai_agent = ZyndAIAgent(agent_config=agent_config)
+print(f"Webhook server running at: {zyndai_agent.webhook_url}")
+
 # Connect to a discovered agent
 zyndai_agent.connect_agent(selected_agent)
 
-# Send encrypted message
+# Send encrypted message via HTTP POST
 result = zyndai_agent.send_message(
     message_content="Can you help me analyze this dataset?",
     message_type="query"
@@ -333,6 +386,44 @@ result = zyndai_agent.send_message(
 messages = zyndai_agent.read_messages()
 ```
 
+**Webhook Mode Features:**
+- ✅ No external broker required
+- ✅ Standard HTTP/HTTPS communication
+- ✅ Easy to deploy and debug
+- ✅ Works behind firewalls with port forwarding
+- ✅ Auto-retry on port conflicts (tries ports 5000-5010)
+- ✅ Built-in health check endpoint (`/health`)
+
+#### MQTT Mode (Legacy)
+
+Traditional MQTT broker-based communication. Requires a running MQTT broker.
+
+```python
+agent_config = AgentConfig(
+    mqtt_broker_url="mqtt://registry.zynd.ai:1883",  # MQTT broker
+    default_outbox_topic=None,
+    auto_reconnect=True,
+    message_history_limit=100,
+    registry_url="https://registry.zynd.ai",
+    identity_credential_path="./identity_credential.json",
+    secret_seed=os.environ["AGENT_SEED"]
+)
+
+zyndai_agent = ZyndAIAgent(agent_config=agent_config)
+
+# Connect to a discovered agent
+zyndai_agent.connect_agent(selected_agent)
+
+# Send encrypted message via MQTT
+result = zyndai_agent.send_message(
+    message_content="Can you help me analyze this dataset?",
+    message_type="query"
+)
+```
+
+**Migration from MQTT to Webhooks:**
+To migrate existing agents, simply change your configuration from `mqtt_broker_url` to `webhook_host` and `webhook_port`. All other code remains the same!
+
 ### 🔐 Identity Verification
 
 Verify other agents' identities before trusting them:
@@ -442,9 +533,9 @@ from zyndai_agent.agent import AgentConfig, ZyndAIAgent
 from zyndai_agent.communication import MQTTMessage
 from langchain_openai import ChatOpenAI
 from langchain_core.tools import tool
-from langchain.agents import create_tool_calling_agent, AgentExecutor
+from langchain_classic.agents import create_tool_calling_agent, AgentExecutor
 from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
-from langchain.memory import ConversationBufferMemory
+from langchain_core.chat_history import InMemoryChatMessageHistory
 import json
 
 @tool
@@ -496,10 +587,12 @@ zyndai_agent = ZyndAIAgent(agent_config=agent_config)
 # Create LangChain agent with custom tool
 llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
 tools = [compare_stocks]
-memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
+
+# Create message history store
+message_history = InMemoryChatMessageHistory()
 
 prompt = ChatPromptTemplate.from_messages([
-    ("system", """You are a Stock Comparison Agent. 
+    ("system", """You are a Stock Comparison Agent.
     Use the compare_stocks tool to analyze stock data.
     Capabilities: stock_comparison, financial_analysis, investment_advice"""),
     MessagesPlaceholder(variable_name="chat_history"),
@@ -508,14 +601,25 @@ prompt = ChatPromptTemplate.from_messages([
 ])
 
 agent = create_tool_calling_agent(llm, tools, prompt)
-agent_executor = AgentExecutor(agent=agent, tools=tools, memory=memory, verbose=True)
+agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
 
 zyndai_agent.set_agent_executor(agent_executor)
 
 # Message handler
 def message_handler(message: MQTTMessage, topic: str):
     print(f"Received: {message.content}")
-    response = zyndai_agent.agent_executor.invoke({"input": message.content})
+
+    # Add user message to history
+    message_history.add_user_message(message.content)
+
+    response = zyndai_agent.agent_executor.invoke({
+        "input": message.content,
+        "chat_history": message_history.messages
+    })
+
+    # Add AI response to history
+    message_history.add_ai_message(response["output"])
+
     zyndai_agent.send_message(response["output"])
 
 zyndai_agent.add_message_handler(message_handler)
@@ -535,13 +639,21 @@ while True:
 
 | Parameter | Type | Default | Description |
 |-----------|------|---------|-------------|
-| `auto_reconnect` | `bool` | `True` | Auto-reconnect to MQTT broker on disconnect |
+| `webhook_host` | `str` | `"0.0.0.0"` | **Webhook mode**: Host address to bind webhook server |
+| `webhook_port` | `int` | `5000` | **Webhook mode**: Port number for webhook server |
+| `webhook_url` | `str` | `None` | **Webhook mode**: Public URL (auto-generated if None) |
+| `api_key` | `str` | `None` | **Webhook mode**: API key for webhook registration (required for webhook mode) |
+| `mqtt_broker_url` | `str` | `None` | **MQTT mode**: MQTT broker connection URL |
+| `default_outbox_topic` | `str` | `None` | **MQTT mode**: Default topic for outgoing messages |
+| `auto_reconnect` | `bool` | `True` | Auto-reconnect/restart on disconnect |
 | `message_history_limit` | `int` | `100` | Maximum messages to keep in history |
 | `registry_url` | `str` | `"http://localhost:3002"` | ZyndAI registry service URL |
-| `mqtt_broker_url` | `str` | Required | MQTT broker connection URL |
-| `identity_credential_path` | `str` | Required | Path to your credential file |
+| `identity_credential_path` | `str` | Required | Path to your DID credential file |
 | `secret_seed` | `str` | Required | Your agent's secret seed |
-| `default_outbox_topic` | `str` | `None` | Default topic for outgoing messages |
+
+**Note**:
+- Configure either `webhook_port` (recommended) OR `mqtt_broker_url`, not both.
+- When using webhook mode, `api_key` is required for registering your webhook URL with the registry.
 
 ### Message Types
 
@@ -777,7 +889,7 @@ We welcome contributions! Here's how to get started:
 
 ### Development Setup
 ```bash
-git clone https://github.com/P3-AI-Network/zyndai-agent.git
+git clone https://github.com/Zynd-AI-Network/zyndai-agent.git
 cd zyndai-agent
 python -m venv venv
 source venv/bin/activate  # On Windows: venv\Scripts\activate
@@ -812,11 +924,92 @@ Create agents for real-time market data (x402), technical analysis by agents, se
 ### 6. Content Generation with Fact-Checking
 Orchestrate agents for research, writing, accessing paid fact-checking APIs via x402, and publishing verified content.
 
+## 🔧 Troubleshooting
+
+### Webhook Mode Issues
+
+**Port Already in Use**
+```
+The SDK automatically tries ports 5000-5010 if the configured port is busy.
+Check the console output for the actual port being used.
+```
+
+**Agent Behind NAT/Firewall**
+```python
+# Specify your public webhook URL manually
+agent_config = AgentConfig(
+    webhook_host="0.0.0.0",
+    webhook_port=5000,
+    webhook_url="https://my-public-domain.com/webhook",  # Your public URL
+    ...
+)
+```
+
+**Running Multiple Agents Locally**
+```python
+# Agent 1: Port 5000
+agent1_config = AgentConfig(webhook_port=5000, ...)
+
+# Agent 2: Port 5001
+agent2_config = AgentConfig(webhook_port=5001, ...)
+
+# Agent 3: Port 5002
+agent3_config = AgentConfig(webhook_port=5002, ...)
+```
+
+**Target Agent Offline**
+```
+When sending messages, you'll receive clear error messages:
+- "Error: Could not connect to target agent. Agent may be offline."
+- "Error: Request timed out. Target agent may be offline."
+
+The SDK does not automatically retry failed webhooks.
+```
+
+**Health Check**
+```bash
+# Check if webhook server is running
+curl http://localhost:5000/health
+
+# Response:
+# {"status": "ok", "agent_id": "did:polygonid:...", "timestamp": 1234567890}
+```
+
+### MQTT Mode Issues
+
+**Connection Refused**
+```
+Ensure your MQTT broker URL is correct and the broker is running.
+Default: mqtt://registry.zynd.ai:1883
+```
+
+**Messages Not Being Received**
+```
+Check that agents are subscribed to the correct topics.
+Verify encryption credentials match between agents.
+```
+
+### General Issues
+
+**Decryption Failures**
+```
+Ensure both agents have the correct DID credentials.
+Verify secret_seed matches the identity_credential_path.
+Check that credentials haven't been regenerated.
+```
+
+**Registry Connection Errors**
+```
+Verify registry_url is correct.
+Check network connectivity to registry.
+Ensure webhook URL or MQTT broker info was successfully registered.
+```
+
 ## 🆘 Support & Community
 
-- **GitHub Issues**: [Report bugs or request features](https://github.com/P3-AI-Network/zyndai-agent/issues)
+- **GitHub Issues**: [Report bugs or request features](https://github.com/Zynd-AI-Network/zyndai-agent/issues)
 - **Documentation**: [Full API Documentation](https://docs.zynd.ai)
-- **Email**: p3ainetwork@gmail.com
+- **Email**: zyndainetwork@gmail.com
 - **Twitter**: [@ZyndAI](https://x.com/ZyndAI)
 
 ## 📄 License
@@ -838,6 +1031,8 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 - [x] End-to-end encryption
 - [x] LangChain integration
 - [x] x402 micropayment support
+- [x] HTTP Webhook communication mode
+- [ ] WebSocket support for real-time bidirectional communication
 - [ ] Support for additional LLM providers (Anthropic, Cohere, etc.)
 - [ ] Web dashboard for agent monitoring and payment tracking
 - [ ] Advanced orchestration patterns (workflows, state machines)
@@ -846,6 +1041,7 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 - [ ] Enhanced security features (rate limiting, access control)
 - [ ] Performance optimizations for high-throughput scenarios
 - [ ] x402 payment analytics and budgeting tools
+- [ ] Webhook authentication and rate limiting
 
 ---
 

zyndai_agent-0.2.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+zyndai_agent/__init__.py,sha256=HQIL1JElpM14oOWl_7LKQeSxbDSeFMnt7goBFpI7D7I,709
+zyndai_agent/agent.py,sha256=bko2GuGJ4Cd8Ra9IaFncs5j2-OgEcvlR5KW-4sWk1rQ,6262
+zyndai_agent/communication.py,sha256=kMHvlSoj5aL3pfVxfiQImQQDl5VFC1zXUxX-_PwcFrM,21118
+zyndai_agent/identity.py,sha256=9W9iDcrAg07jxE4llrubW1poYBTVtONddyDULGUSnV8,3906
+zyndai_agent/message.py,sha256=nXpKboqAyv-V2bDbgyZ84NerZhGLjYt-lAeM7ndFLTs,3974
+zyndai_agent/payment.py,sha256=Yxnm8rbSB0B2t78jJwGobtcpRbQlM3lSLpUljohhDgc,6238
+zyndai_agent/search.py,sha256=cSLoD4NCXYGo2YiGYE7xYrJr90c_6WjEjoWPQBgu78g,2129
+zyndai_agent/utils.py,sha256=YN1EXGawaUPiPRyPszYvZ7lwTgimmca2DQeW_8nFjRo,16634
+zyndai_agent/webhook_communication.py,sha256=UgyXlNYqooGVoeWqn3uLke8G9vqKBqE1fcFpe1C_mpw,16912
+zyndai_agent-0.2.1.dist-info/METADATA,sha256=FDNvaFcQSzma2Vm8dbWr7d7ERrXacOViaI_d8d7HHMc,37007
+zyndai_agent-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+zyndai_agent-0.2.1.dist-info/top_level.txt,sha256=6jE9hyvpa18fstxa4omi9X2c97rawKydn6NwMwVSql4,13
+zyndai_agent-0.2.1.dist-info/RECORD,,

zyndai_agent-0.1.4.dist-info/RECORD

@@ -1,11 +0,0 @@
-zyndai_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-zyndai_agent/agent.py,sha256=j2ZKpZAmZ23g5GHa1l61CDpOXrG-w0KWIqH9Bgvkytg,3102
-zyndai_agent/communication.py,sha256=kMHvlSoj5aL3pfVxfiQImQQDl5VFC1zXUxX-_PwcFrM,21118
-zyndai_agent/identity.py,sha256=9W9iDcrAg07jxE4llrubW1poYBTVtONddyDULGUSnV8,3906
-zyndai_agent/payment.py,sha256=Yxnm8rbSB0B2t78jJwGobtcpRbQlM3lSLpUljohhDgc,6238
-zyndai_agent/search.py,sha256=rYIs39ZM8iXFrv6Zb548UMeWQYjiTO7Ou_2vhvscLPM,2013
-zyndai_agent/utils.py,sha256=YN1EXGawaUPiPRyPszYvZ7lwTgimmca2DQeW_8nFjRo,16634
-zyndai_agent-0.1.4.dist-info/METADATA,sha256=MLKGZCW72HucmuQ1xzbqFE4fIYHPXqTLxVJgEzGVnQA,30709
-zyndai_agent-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-zyndai_agent-0.1.4.dist-info/top_level.txt,sha256=6jE9hyvpa18fstxa4omi9X2c97rawKydn6NwMwVSql4,13
-zyndai_agent-0.1.4.dist-info/RECORD,,