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

zyndai_agent/__init__.py

@@ -0,0 +1,22 @@
+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
+from zyndai_agent.config_manager import ConfigManager
+
+__all__ = [
+    "ZyndAIAgent",
+    "AgentConfig",
+    "AgentCommunicationManager",
+    "WebhookCommunicationManager",
+    "MQTTMessage",
+    "AgentMessage",
+    "SearchAndDiscoveryManager",
+    "AgentSearchResponse",
+    "IdentityManager",
+    "X402PaymentProcessor",
+    "ConfigManager",
+]

zyndai_agent/agent.py

@@ -3,56 +3,102 @@ 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 zyndai_agent.config_manager import ConfigManager
 from pydantic import BaseModel
 from typing import Optional
 from langchain.agents import create_agent
 from langgraph.graph.state import CompiledStateGraph
 
 class AgentConfig(BaseModel):
+    name: str = ""
+    description: str = ""
+    capabilities: Optional[dict] = None
+
     auto_reconnect: bool = True
     message_history_limit: int = 100
     registry_url: str = "http://localhost:3002"
-    mqtt_broker_url: str
-    identity_credential_path: str
-    identity_credential: Optional[dict] = None
+
+    # 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
-    secret_seed: str = None
 
-class ZyndAIAgent(SearchAndDiscoveryManager, IdentityManager, AgentCommunicationManager, X402PaymentProcessor):
+    price: Optional[str] = None
 
-    def __init__(self, agent_config: AgentConfig): 
+    # Config directory for agent identity (allows multiple agents in same project)
+    config_dir: Optional[str] = None  # e.g., ".agent-stock" or ".agent-user"
+
+class ZyndAIAgent(SearchAndDiscoveryManager, IdentityManager, X402PaymentProcessor, WebhookCommunicationManager):
+
+    def __init__(self, agent_config: AgentConfig):
 
         self.agent_executor: CompiledStateGraph = None
-        self.agent_config = agent_config 
-        self.x402_processor = X402PaymentProcessor(agent_config.secret_seed)
+        self.agent_config = agent_config
+        self.communication_mode = None  # Track which mode is active
+
+        # Load or create agent config from .agent/config.json
+        config = ConfigManager.load_or_create(agent_config)
+        self.registry_agent_id = config["id"]
+        self.agent_id = config["id"]
+        self.secret_seed = config["seed"]
+        self.identity_credential = config["did"]
 
-        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)
+        self.x402_processor = X402PaymentProcessor(self.secret_seed)
+        self.pay_to_address = self.x402_processor.account.address
+
+        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=self.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=self.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")
+
+        # Display agent info
+        self._display_agent_info()
 
 
 
@@ -62,16 +108,79 @@ 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,
+                "seed": self.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.")
+
+        headers = {
+            "accept": "*/*",
+            "X-API-KEY": self.agent_config.api_key
+        }
+
+        payload = {
+            "agentId": self.registry_agent_id,
+            "httpWebhookUrl": self.webhook_url
+        }
+
+        print(f"Updating webhook URL: {payload}")
+
+        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 _display_agent_info(self):
+        """Display agent information in a pretty format on startup."""
+        name = self.agent_config.name or "Unnamed Agent"
+        description = self.agent_config.description or "-"
+        agent_id = self.agent_id
+        address = self.pay_to_address
+        did = self.identity_credential.get("issuer", "-")
+        mode = self.communication_mode or "-"
+        webhook_url = getattr(self, "webhook_url", None)
+        price = self.agent_config.price or "Free"
+
+        border = "=" * 60
+        print(f"\n{border}")
+        print(f"  ZYND AI AGENT")
+        print(f"{border}")
+        print(f"  Name        : {name}")
+        print(f"  Description : {description}")
+        print(f"  Agent ID    : {agent_id}")
+        print(f"  DID         : {did}")
+        print(f"  Address     : {address}")
+        print(f"  Mode        : {mode}")
+        if webhook_url:
+            print(f"  Webhook URL : {webhook_url}")
+        print(f"  Price       : {price}")
+        print(f"{border}\n")
+
+    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/config_manager.py

@@ -0,0 +1,153 @@
+import os
+import json
+import requests
+
+
+class ConfigManager:
+    """
+    Manages agent configuration stored in .agent/config.json.
+
+    On first run, provisions a new agent via the registry API and saves
+    the identity credentials locally. On subsequent runs, loads the
+    saved config so the user doesn't need to provide identity credentials manually.
+    """
+
+    DEFAULT_CONFIG_DIR = ".agent"
+    CONFIG_FILE = "config.json"
+
+    @staticmethod
+    def _config_path(config_dir: str = None):
+        dir_name = config_dir or ConfigManager.DEFAULT_CONFIG_DIR
+        return os.path.join(os.getcwd(), dir_name, ConfigManager.CONFIG_FILE)
+
+    @staticmethod
+    def _config_dir(config_dir: str = None):
+        dir_name = config_dir or ConfigManager.DEFAULT_CONFIG_DIR
+        return os.path.join(os.getcwd(), dir_name)
+
+    @staticmethod
+    def load_config(config_dir: str = None):
+        """Load existing config from .agent/config.json. Returns None if not found."""
+        config_path = ConfigManager._config_path(config_dir)
+        if not os.path.exists(config_path):
+            return None
+
+        with open(config_path, "r") as f:
+            config = json.load(f)
+
+        print(f"Loaded agent config from {config_path}")
+        return config
+
+    @staticmethod
+    def save_config(config: dict, config_dir: str = None):
+        """Save config to .agent/config.json, creating the directory if needed."""
+        dir_path = ConfigManager._config_dir(config_dir)
+        os.makedirs(dir_path, exist_ok=True)
+
+        config_path = ConfigManager._config_path(config_dir)
+        with open(config_path, "w") as f:
+            json.dump(config, f, indent=2)
+
+        print(f"Saved agent config to {config_path}")
+
+    @staticmethod
+    def create_agent(registry_url: str, api_key: str, name: str, description: str, capabilities: dict, config_dir: str = None):
+        """
+        Create a new agent via the registry API.
+
+        Args:
+            registry_url: Base URL of the agent registry
+            api_key: API key for authentication
+            name: Agent display name
+            description: Agent description
+            capabilities: Agent capabilities dict (e.g. {"ai": ["nlp"], "protocols": ["http"]})
+            config_dir: Custom config directory (e.g., ".agent-stock")
+
+        Returns:
+            dict: The saved config with id, didIdentifier, did, name, description, seed
+        """
+        headers = {
+            "accept": "application/json",
+            "Content-Type": "application/json",
+            "x-api-key": api_key
+        }
+
+        payload = {
+            "name": name,
+            "description": description,
+            "capabilities": capabilities,
+            "status": "ACTIVE"
+        }
+
+        response = requests.post(
+            f"{registry_url}/agents",
+            json=payload,
+            headers=headers
+        )
+
+        if response.status_code not in (200, 201):
+            raise RuntimeError(
+                f"Failed to create agent via registry API. "
+                f"Status: {response.status_code}, Response: {response.text}"
+            )
+
+        data = response.json()
+
+        # The 'did' field in the API response is a JSON string; parse it
+        did = data["did"]
+        if isinstance(did, str):
+            did = json.loads(did)
+
+        config = {
+            "id": data["id"],
+            "didIdentifier": data["didIdentifier"],
+            "did": did,
+            "name": data["name"],
+            "description": data["description"],
+            "seed": data["seed"]
+        }
+
+        ConfigManager.save_config(config, config_dir)
+        return config
+
+    @staticmethod
+    def load_or_create(agent_config):
+        """
+        Load existing agent config or create a new agent.
+
+        If .agent/config.json exists, returns stored values.
+        Otherwise, calls the registry API to provision a new agent.
+
+        Args:
+            agent_config: AgentConfig instance with registry_url, api_key, name,
+                          description, capabilities, and optional config_dir
+
+        Returns:
+            dict with keys: id, didIdentifier, did, name, description, seed
+        """
+        config_dir = getattr(agent_config, 'config_dir', None)
+        config = ConfigManager.load_config(config_dir)
+        if config is not None:
+            return config
+
+        # Validate required fields for agent creation
+        if not agent_config.api_key:
+            raise ValueError(
+                "api_key is required in AgentConfig to create a new agent. "
+                "Provide an API key or place a .agent/config.json in the working directory."
+            )
+        if not agent_config.name:
+            raise ValueError("name is required in AgentConfig to create a new agent.")
+        if not agent_config.capabilities:
+            raise ValueError("capabilities is required in AgentConfig to create a new agent.")
+
+        dir_name = config_dir or ConfigManager.DEFAULT_CONFIG_DIR
+        print(f"No {dir_name}/config.json found. Creating a new agent...")
+        return ConfigManager.create_agent(
+            registry_url=agent_config.registry_url,
+            api_key=agent_config.api_key,
+            name=agent_config.name,
+            description=agent_config.description,
+            capabilities=agent_config.capabilities,
+            config_dir=config_dir
+        )

zyndai_agent/message.py

@@ -0,0 +1,112 @@
+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,
+            "prompt": 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("prompt", 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