agent-dna 0.1.0__py3-none-any.whl

agent_dna-0.1.0.dist-info/METADATA

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: agent-dna
+Version: 0.1.0
+Summary: AgentDNA: Verifiable and Auditable AI Agents
+Author: Aparna Ullas
+License: MIT
+Project-URL: Homepage, https://github.com/rubixchain/agentdna
+Project-URL: Repository, https://github.com/rubixchain/agentdna
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: rubix-py
+Dynamic: license-file
+
+
+# AgentDNA
+
+AgentDNA is a package that helps in auditing and verifiability of Agents within a multi-agent communication system.
+
+
+## Key Features
+- **Unified trust layer** for multi-agent systems  
+- Automatically manages:
+  - DID setup  
+  - Signing traces of conversation  
+  - Verification of Agent conversation  
+- Immutable audit logging
+- Fully compatible with:
+  - Google A2A protocol 
+  - ADK, Crew and LangGraph frameworks 
+
+## Installation
+```
+# Installation via pip
+pip install agent-dna
+
+# Installation via uv
+uv add agent-dna
+```
+
+## Architecture
+AgentDNA internally wraps several layers to keep agent developers free from Rubix-specific complexity.
+
+```
+┌─────────────────────────┐
+│      Agent Developer    │
+│  dna.build() / handle() │
+└─────────────┬───────────┘
+              │
+┌─────────────────────────┐
+│       AgentDNA          │
+│ role = "host" | "remote"│
+└─────────────┬───────────┘
+              │
+┌─────────────────────────┐
+│   RubixMessageHandler   |
+│ - build host/agent msgs │
+│ - parse & verify inbound│
+│ - NFT execution (host)  │
+└─────────────┬───────────┘
+              │
+┌───────────────────────────┐
+│    RubixTrustService      │
+│ - DID management          │
+│ - sign_envelope()         │
+│ - verify_envelope()       │
+│ - verify_message_payload()│
+└─────────────┬─────────────┘
+              │
+┌─────────────────────────┐
+│       rubix-py SDK      │
+│ RubixClient             │
+│ Signer                  │
+│ Querier                 │
+└─────────────────────────┘
+```
+
+## Agent Roles
+AgentDNA supports two roles:
+
+### **Host Agent**
+Responsible for:
+- Signing and sending outgoing **host_request**
+- Verifying inbound **agent_response**
+- Optional **NFT execution** for audit logging
+
+### **Remote Agent**
+Responsible for:
+- Verifying inbound **host_request**
+- Signing outbound **agent_response**
+
+## Quick Start Example
+### **Initializing**
+```python
+from agentdna import AgentDNA
+
+dna = AgentDNA(alias="<agent alias>", role="<host/remote>")
+
+```
+### **Remote Agents**
+```python
+verify_info = await dna.handle(raw_text=raw_message, verify_mode="<light/heavy>")
+
+reply = run_llm(original_msg)
+
+built = dna.build(
+    original_message=original_msg,
+    response=reply,
+    host_block=host_block,
+)
+```
+
+### **Host Agent**
+```python
+outbound = dna.build(
+    original_message="Are you free tomorrow?",
+    state={"task_id": tid, "context_id": cid}
+)
+
+result = await self.dna.handle(
+    resp_parts=resp_parts,
+    original_task=task,
+    remote_name=agent_name,
+)
+```
+
+## Project Structure
+```
+agentdna/
+ ├── core.py
+ ├── handler.py
+ ├── trust.py
+ ├── node_client.py
+ └── ...
+```
+
+## Examples
+Full Host, ADK, and LangGraph examples can be found inside `examples/`.
+
+## License
+MIT

agent_dna-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+agent_dna-0.1.0.dist-info/licenses/LICENSE,sha256=z-etQrfD3bh3LfZy8QAeZFfOXc756qqm8nF3nmfosVM,1056
+agentdna/__init__.py,sha256=SEjlUt6r4nPJLyQtEDY7AQZI4T5q6d7yiGpdeStgk_o,313
+agentdna/core.py,sha256=e7hm8FRJqV1DyPRzU8n4vn2LFwvQavhfFdR-PaOYgZw,3877
+agentdna/handler.py,sha256=QXsY8Bz93sVFoEpioOLUTjeCwkTko9X1f3nXS5N-Rdc,16450
+agentdna/node_client.py,sha256=otELq96XzxNi0rWJ2tGnzUuB-utUQ-HL3KlX1t5Zy_c,2240
+agentdna/token.txt,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentdna/trust.py,sha256=ZtHLXh9SkFoYkdxhu40c0Kn8Szp_7NQPMXwTRjkIbAg,7227
+agent_dna-0.1.0.dist-info/METADATA,sha256=RPJFECGENL1KrJZ3gofAixNwkrt3cx5Q5SDVrvbqqI8,3838
+agent_dna-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+agent_dna-0.1.0.dist-info/top_level.txt,sha256=GXaMD8TQm5cw2l98vgE7d7nYahdrYCuJAmh2-7Z0iS4,9
+agent_dna-0.1.0.dist-info/RECORD,,

agent_dna-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

agent_dna-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

agent_dna-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+agentdna

agentdna/__init__.py

@@ -0,0 +1,16 @@
+"""
+rubix.agent.dna
+Public interface for Rubix agent DNA utilities.
+"""
+
+from .trust import RubixTrustService
+from .handler import RubixMessageHandler
+from .node_client import NodeClient
+from .core import AgentDNA
+
+__all__ = [
+    "RubixTrustService",
+    "RubixMessageHandler",
+    "NodeClient",
+    "AgentDNA"
+]

agentdna/core.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+from typing import Any, Dict
+
+from .trust import RubixTrustService
+from .handler import RubixMessageHandler
+
+
+class AgentDNA:
+    """
+    Single entry point for agent developers.
+
+    They only call:
+        dna.build(...)          # outbound message (request or response)
+        await dna.handle(...)   # inbound message (request or response)
+
+    Behavior is decided purely by `role`:
+
+      role="host":
+        - build  -> host_request      (host → remote)
+        - handle -> host              (remote → host, verify + NFT)
+
+      role="remote":
+        - build  -> agent_response    (remote → host)
+        - handle -> remote            (host → remote, verify host)
+    """
+
+    def __init__(
+        self,
+        alias: str,
+        role: str = "remote",        # "host" or "remote"
+        token_filename: str = "token.txt",
+    ) -> None:
+        if role not in ("host", "remote"):
+            raise ValueError("AgentDNA.role must be 'host' or 'remote'")
+
+        self.role = role
+        self.trust = RubixTrustService(alias=alias)
+
+        self.handler = RubixMessageHandler(
+            alias=alias,
+            token_filename=token_filename,
+            trust_service=self.trust,
+            enable_nft=(role == "host"),
+        )
+
+    # ------------------------------------------------------------------
+    # BUILD: outbound messages
+    # ------------------------------------------------------------------
+    def build(self, **kwargs) -> Dict[str, Any]:
+        """
+        Host:
+            dna.build(
+                original_message=task,
+                state=tool_context.state or {},
+            )
+
+        Remote:
+            dna.build(
+                original_message=original_message,
+                response=agent_reply_text,
+                host_block=host_block,
+                extra={...},
+            )
+        """
+        if self.role == "host":
+            if "original_message" not in kwargs:
+                raise ValueError("Host.build() requires original_message")
+            return self.handler.build(
+                kind="host_request",
+                **kwargs,
+            )
+
+        # remote
+        if "original_message" not in kwargs or "response" not in kwargs:
+            raise ValueError("Remote.build() requires original_message and response")
+        return self.handler.build(
+            kind="agent_response",
+            **kwargs,
+        )
+
+    # ------------------------------------------------------------------
+    # HANDLE: inbound messages
+    # ------------------------------------------------------------------
+    async def handle(self, **kwargs) -> Dict[str, Any]:
+        """
+        Host:
+            result = await dna.handle(
+                resp_parts=resp_parts,
+                original_task=task,
+                remote_name=agent_name,
+                execute_nft=True,
+            )
+
+        Remote:
+            verify_info = await dna.handle(
+                raw_text=raw,
+                verify_mode="light",
+            )
+        """
+        if self.role == "remote":
+            # Remote handling inbound from host
+            raw_text = kwargs.get("raw_text")
+            if raw_text is None:
+                raise ValueError("Remote.handle() requires raw_text")
+
+            mode = kwargs.get("verify_mode", "light")
+            # trust.verify_message_payload is sync, but it's fine to call
+            return self.trust.verify_message_payload(
+                raw_text=raw_text,
+                mode=mode,
+            )
+
+        # Host handling inbound from remotes
+        for required in ("resp_parts", "original_task", "remote_name"):
+            if required not in kwargs:
+                raise ValueError(f"Host.handle() requires {required}")
+        return await self.handler.handle(
+            kind="host",
+            **kwargs,
+        )

agentdna/handler.py

@@ -0,0 +1,478 @@
+import asyncio
+import json
+import os
+import uuid
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from .trust import RubixTrustService
+
+
+def load_nft_config() -> dict:
+    """
+    Load NFT settings (paths + value + init data) from env,
+    with defaults suitable for the pickleball demo.
+    """
+    return {
+        "artifact_path": os.getenv("NFT_ARTIFACT_PATH", "artifacts/pickleball.json"),
+        "metadata_path": os.getenv("NFT_METADATA_PATH", "artifacts/pickleball-meta.json"),
+        "value": float(os.getenv("NFT_VALUE", "0.001")),
+        "data": os.getenv("NFT_INIT_DATA", "init data"),
+    }
+
+
+class RubixMessageHandler:
+    """
+    High-level Rubix helper for A2A agents.
+
+    It exposes ONLY two main calls for developers:
+
+      - build(...)
+      - handle(...)
+
+    and hides all Rubix / NFT details inside.
+
+    Usage patterns
+    --------------
+
+    1) Host → Remote: build the signed host block, then embed into A2A message:
+
+        dna = RubixMessageHandler(alias="host")
+
+        built = dna.build(
+            kind="host_request",
+            original_message=task_text,
+            state={"task_id": task_id, "context_id": context_id},  # optional
+        )
+
+        # built["host_json"] is what you put into the A2A text part
+        host_json   = built["host_json"]
+        message_id  = built["message_id"]
+        context_id  = built["context_id"]
+
+        # A2A payload (example)
+        payload = {
+            "message": {
+                "role": "user",
+                "parts": [
+                    {"type": "text", "text": host_json},
+                ],
+                "messageId": message_id,
+                "contextId": context_id,
+            }
+        }
+
+    2) Remote agent (Karley / Nate / Kaitlyn) when receiving a message:
+
+        dna = RubixMessageHandler(alias="karley", enable_nft=False)
+
+        verify_info = await dna.handle(
+            kind="incoming_request",
+            raw_text=raw_from_context,
+            verify_mode="light",   # or "heavy" in future
+        )
+
+        original_message = verify_info["original_message"]
+        host_block       = verify_info["host_block"]
+        host_ok          = verify_info["host_ok"]
+        trust_issues     = verify_info["trust_issues"]
+
+        # Use original_message for your local LLM/ADK agent
+
+    3) Remote agent → Host: sign its response in a symmetric way:
+
+        built_resp = dna.build(
+            kind="agent_response",
+            original_message=original_message,
+            response=agent_result,
+            host_block=host_block,
+            extra={"host_trust_issues": trust_issues},
+        )
+
+        # Put built_resp["combined_json"] into your A2A text part
+
+    4) Host handling remote responses (verify + optional NFT):
+
+        result = await dna.handle(
+            kind="host_response",
+            resp_parts=resp_parts,      # list of {"text": "..."} from A2A artifacts
+            original_task=task_text,
+            remote_name=agent_name,
+            execute_nft=True,           # will store in NFT if verification passes
+        )
+
+        messages     = result["messages"]      # verified messages w/ host+agent blocks
+        trust_issues = result["trust_issues"]  # any issues
+        nft_result   = result["nft_result"]    # optional: NFT execution response / None
+    """
+
+    def __init__(
+        self,
+        alias: str,
+        token_filename: str = "token.txt",
+        trust_service: Optional[RubixTrustService] = None,
+        enable_nft: bool = True,
+    ) -> None:
+        # Trust layer (sign + verify + verify_message_payload)
+        self.trust = trust_service or RubixTrustService(alias=alias)
+        self.did = self.trust.did
+        self.signer = self.trust.signer
+
+        # NFT config
+        self.enable_nft = enable_nft
+        self.nft_cfg = load_nft_config()
+        self.last_parts: List[Dict[str, Any]] = []
+
+        # Where to store NFT token (host project, not site-packages)
+        self.token_path: Optional[Path] = None
+        self.nft_token: Optional[str] = None
+
+        if self.enable_nft:
+            env_path = os.getenv("AGENTDNA_TOKEN_PATH")
+            if env_path:
+                self.token_path = Path(env_path)
+            else:
+                project_root = Path.cwd()   # e.g. /.../host_agent_adk
+                token_dir = project_root / ".agentdna"
+                token_dir.mkdir(parents=True, exist_ok=True)
+                self.token_path = token_dir / token_filename
+
+            print("Path:", self.token_path)
+            self.nft_token = self._load_or_deploy_nft()
+            print("✅ Rubix NFT for alias", alias, ":", self.nft_token)
+        else:
+            print("ℹ️ RubixMessageHandler(enable_nft=False) – NFT operations disabled")
+
+    # ======================================================================
+    # Public API: BUILD
+    # ======================================================================
+
+    def build(
+        self,
+        *,
+        kind: str,
+        original_message: str,
+        state: Optional[Dict[str, Any]] = None,
+        response: Optional[str] = None,
+        host_block: Optional[Dict[str, Any]] = None,
+        extra: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Unified build() method.
+
+        kind:
+          - "host_request"   : host builds + signs a host envelope
+          - "agent_response" : remote builds + signs its agent envelope and
+                               combines it with the host block
+        """
+        kind = (kind or "").lower().strip()
+        state = state or {}
+        extra = extra or {}
+        print(f"[RubixMessageHandler.build] kind={kind}")
+        if kind == "host_request":
+            # host → remote
+            return self._build_host_request(
+                original_message=original_message,
+                state=state,
+            )
+
+        if kind == "agent_response":
+            # remote → host
+            if response is None:
+                raise ValueError("build(kind='agent_response') requires `response`.")
+            return self._build_agent_response(
+                original_message=original_message,
+                response=response,
+                host_block=host_block,
+                extra=extra,
+            )
+
+        raise ValueError(f"Unsupported build kind: {kind}")
+    # ======================================================================
+    # API: HANDLE
+    # ======================================================================
+
+    async def handle(
+        self,
+        *,
+        kind: str,
+        raw_text: Optional[str] = None,
+        resp_parts: Optional[List[Dict[str, Any]]] = None,
+        original_task: Optional[str] = None,
+        remote_name: Optional[str] = None,
+        verify_mode: str = "light",
+        execute_nft: bool = True,
+    ) -> Dict[str, Any]:
+        kind = (kind or "").lower().strip()
+
+        if kind == "remote":
+            # remote agent handling inbound from host
+            if raw_text is None:
+                raise ValueError("handle(kind='remote') requires raw_text.")
+            return self.trust.verify_message_payload(raw_text=raw_text, mode=verify_mode)
+
+        if kind == "host":
+            # host handling inbound from remote
+            if resp_parts is None or original_task is None or remote_name is None:
+                raise ValueError(
+                    "handle(kind='host') requires resp_parts, original_task, remote_name."
+                )
+            return await self._handle_host_response(
+                resp_parts=resp_parts,
+                original_task=original_task,
+                remote_name=remote_name,
+                execute_nft=execute_nft,
+            )
+
+        raise ValueError(f"Unsupported handle kind: {kind}")
+
+    # ======================================================================
+    # Internal: host request building
+    # ======================================================================
+
+    def _build_host_request(
+        self,
+        original_message: str,
+        state: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        task_id = state.get("task_id") or str(uuid.uuid4())
+        context_id = state.get("context_id") or str(uuid.uuid4())
+        message_id = str(uuid.uuid4())
+
+        host_envelope = {
+            "original_message": original_message,
+            "task_id":          task_id,
+            "context_id":       context_id,
+            "message_id":       message_id,
+            "timestamp":        datetime.utcnow().isoformat() + "Z",
+        }
+
+        host_block = self.trust.sign_envelope(host_envelope)
+
+        host_json = json.dumps(
+            {"host": host_block},
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+
+        return {
+            "kind":        "host_request",
+            "host_block":  host_block,
+            "host_json":   host_json,
+            "task_id":     task_id,
+            "context_id":  context_id,
+            "message_id":  message_id,
+        }
+
+    # ======================================================================
+    # Internal: agent response building
+    # ======================================================================
+
+    def _build_agent_response(
+        self,
+        original_message: str,
+        response: str,
+        host_block: Optional[Dict[str, Any]],
+        extra: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        envelope = {
+            "original_message": original_message,
+            "response":         response,
+        }
+        # Optionally attach trust metadata (e.g. host_trust_issues)
+        envelope.update(extra)
+
+        agent_block = self.trust.sign_envelope(envelope)
+
+        combined: Dict[str, Any] = {
+            "agent": agent_block,
+        }
+        if host_block is not None:
+            combined["host"] = host_block
+
+        combined_json = json.dumps(
+            combined,
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+
+        return {
+            "kind":          "agent_response",
+            "host_block":    host_block,
+            "agent_block":   agent_block,
+            "envelope":      envelope,
+            "combined_json": combined_json,
+        }
+
+    # ======================================================================
+    # Internal: NFT helpers
+    # ======================================================================
+
+    def execute_nft(self, nft_address: str, payload: Any) -> Dict[str, Any]:
+        """
+        Execute an NFT using the signer from the trust service.
+        """
+        nft_data = json.dumps(payload)
+
+        try:
+            print("NFT address:", nft_address)
+            print("NFT data:", nft_data)
+            response = self.signer.execute_nft(
+                nft_address=nft_address,
+                nft_data=nft_data,
+            )
+        except Exception as e:
+            raise RuntimeError(f"Rubix execute_nft call failed: {e}")
+
+        if not response.get("status", False):
+            raise RuntimeError(
+                f"NFT Execution Failed: {response.get('message', '<no message>')}"
+            )
+
+        return response
+
+    def _load_or_deploy_nft(self) -> str:
+        if not self.token_path:
+            raise RuntimeError("NFT token path not initialized (enable_nft=False?)")
+
+        if self.token_path.exists():
+            token = self.token_path.read_text(encoding="utf-8").strip()
+            if token:
+                print("ℹ️ Using existing NFT token:", token)
+                return token
+            else:
+                print(f"⚠️ {self.token_path} is empty, deploying new NFT…")
+        else:
+            print(f"⚠️ token.txt not found at {self.token_path}, deploying new NFT…")
+
+        print("Creating a new NFT")
+        print("Artifact path:", self.nft_cfg["artifact_path"])
+        print("Metadata path:", self.nft_cfg["metadata_path"])
+
+        resp = self.signer.deploy_nft(
+            artifact_file=self.nft_cfg["artifact_path"],
+            metadata_file=self.nft_cfg["metadata_path"],
+            nft_value=self.nft_cfg["value"] or 0.001,
+            nft_data=self.nft_cfg["data"] or "init data",
+        )
+        if resp.get("error"):
+            raise RuntimeError(f"NFT deployment failed: {resp['error']}")
+
+        nft_address = resp["nft_address"]
+        self.token_path.write_text(nft_address, encoding="utf-8")
+        print("🚀 Deployed new NFT:", nft_address)
+        return nft_address
+
+    # ======================================================================
+    # Internal: host handling remote responses
+    # ======================================================================
+
+    async def _handle_host_response(
+        self,
+        resp_parts: List[Dict[str, Any]],
+        original_task: str,
+        remote_name: str,
+        execute_nft: bool,
+    ) -> Dict[str, Any]:
+        """
+        Old handle_response_parts, but wrapped into handle(kind="host_response").
+        """
+        verified: List[Dict[str, Any]] = []
+        trust_issues: List[str] = []
+        error_msg: Optional[str] = None
+        nft_result: Optional[Dict[str, Any]] = None
+
+        for part in resp_parts:
+            raw_text = part.get("text") or part.get("content", "")
+            try:
+                payload = json.loads(raw_text)
+            except (TypeError, json.JSONDecodeError):
+                continue
+
+            # Expect {"host": {...}, "agent": {...}}
+            if not isinstance(payload, dict) or "agent" not in payload:
+                continue
+
+            host_block = payload.get("host")
+            agent_block = payload["agent"]
+
+            signer_did = agent_block.get("agent")
+            env = agent_block.get("envelope", {})
+            sig = agent_block.get("signature")
+
+            if not (signer_did and env and sig):
+                trust_issues.append("Missing fields in agent block")
+                print("Missing fields in agent block")
+                continue
+
+            # verify via trust service
+            if not self.trust.verify_envelope(signer_did, env, sig):
+                trust_issues.append(f"Invalid signature from {signer_did}")
+                print(f"Invalid signature from {signer_did}")
+                continue
+
+            # Optional consistency check
+            if env.get("original_message") != original_task:
+                trust_issues.append("Original message mismatch")
+                print("Original message mismatch")
+
+            verified.append(
+                {
+                    "host": host_block,
+                    "agent": agent_block,
+                    "agent_sig_valid": True,
+                }
+            )
+            print("Verified agent block from", signer_did)
+
+        if not verified and not trust_issues:
+            error_msg = "No valid envelope response"
+            print("No valid envelope response")
+
+        self.last_parts = verified
+
+        # Optional NFT execution on host
+        if (
+            self.enable_nft
+            and execute_nft
+            and verified
+            and self.nft_token is not None
+        ):
+            try:
+                payload = self._build_nft_payload(remote_name)
+                nft_result = await asyncio.to_thread(
+                    self.execute_nft,
+                    self.nft_token,
+                    payload,
+                )
+                print("🚀 NFT execution result:", nft_result)
+            except Exception as e:
+                print("⚠️ NFT execution failed:", e)
+
+        return {
+            "messages": verified,
+            "trust_issues": trust_issues or None,
+            "error": error_msg,
+            "nft_result": nft_result,
+        }
+
+    def _build_nft_payload(self, remote_name: str) -> Dict[str, Any]:
+        """
+        Build the JSON that will be stored in the NFT.
+        """
+        host_block = None
+        responses: List[Dict[str, Any]] = []
+        for entry in self.last_parts:
+            if not host_block and entry.get("host"):
+                host_block = entry["host"]
+            if entry.get("agent"):
+                responses.append(entry["agent"])
+
+        return {
+            "comment":  f"Pickleball scheduling with {remote_name}",
+            "executor": "host_agent",
+            "did":      self.did,
+            "host":     host_block,
+            "responses": responses,
+        }

agentdna/node_client.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+from pathlib import Path
+import os, json, requests
+from typing import Any, Dict, Optional, List
+
+class NodeClient:
+    """
+    Minimal client for your local node.
+    Resolve base_url from (in order): explicit base_url -> framework name -> port -> config.json -> ENV.
+    """
+
+    def __init__(
+        self,
+        alias: Optional[str] = None, 
+        base_url: Optional[str] = None,
+        config_path: Optional[Union[str, Path]] = None,
+    ):
+        if not config_path:
+          
+            config_path = Path(__file__).resolve().parent.parent / "config.json"
+
+        print("config path:", config_path)
+
+        port = self._read_port(alias, config_path)
+
+        self.base_url = (
+            base_url
+            or os.getenv("BASE_URL")
+            or f"http://localhost:{port or self._read_port_from_config(alias, config_path)}"
+        )
+
+    def get_base_url(self) -> str:
+        return self.base_url
+
+    
+    @staticmethod
+    def _read_port(alias: str, config_path: Optional[Union[str, Path]]) -> Optional[int]:
+        """
+        Reads the port from config.json for the given framework name.
+        Example: framework="host" → key="host_port"
+        """
+        path = Path(os.getenv("CONFIG_PATH") or (config_path or NodeClient._default_config_path()))
+        try:
+            with Path(path).open("r", encoding="utf-8") as f:
+                cfg = json.load(f)
+            key = f"{alias.lower()}"
+            return int(cfg.get(key))
+        except Exception:
+            return None
+
+    @staticmethod
+    def _read_port_from_config(alias: str, config_path: Optional[Union[str, Path]]) -> Optional[int]:
+        """
+        Fallback to reading generic port or langgraph_port if no framework given.
+        """
+        path = Path(os.getenv("CONFIG_PATH") or (config_path or NodeClient._default_config_path()))
+        try:
+            with Path(path).open("r", encoding="utf-8") as f:
+                cfg = json.load(f)
+            return int(cfg.get("port") or cfg.get(alias))
+        except Exception:
+            return None
+
+    @staticmethod
+    def _default_config_path() -> Path:
+        here = Path(__file__).resolve()
+        return here.parents[2] / "config.json"

agentdna/trust.py

@@ -0,0 +1,217 @@
+import json
+import os
+from typing import Any, Dict, Optional, List
+from pathlib import Path
+import requests
+from rubix.client import RubixClient
+from rubix.signer import Signer
+from rubix.did import online_signature_verify, signatureResponseError
+
+from .node_client import NodeClient
+
+
+class RubixTrustService:
+    """
+    Handles:
+      - RubixClient + Signer
+      - DID management
+      - Signing envelopes
+      - Verifying signatures via /api/verify-signature
+    """
+
+    def __init__(
+        self,
+        alias: str,
+        config_path: str = "",
+        timeout: float = 300.0,
+    ) -> None:
+        node = NodeClient(alias=alias)
+        self.base_url = node.get_base_url().rstrip("/")
+        self.timeout = timeout
+
+        config_dir = ""
+        if config_path == "":
+            home_dir = Path.home()
+            config_dir =  os.path.join(home_dir, ".agentdna")
+        else:
+            config_dir = config_path
+
+        client = RubixClient(node_url=self.base_url, timeout=timeout)
+        
+        self.signer = Signer(rubixClient=client, alias=alias, config_path=config_dir)
+        self.did = self.signer.did
+
+        print("✅ RubixTrustService DID:", self.did)
+        print("✅ RubixTrustService base URL:", self.base_url)
+
+    # ---------- signing ----------
+
+    def sign_envelope(self, envelope: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Sign an envelope dict and return a block:
+          { "agent": <did>, "envelope": {...}, "signature": "<hex>" }
+        """
+        print("Agent is going to sign")
+        print("Public Key (hex): ", self.signer.get_keypair().public_key)
+        keypair = self.signer.get_keypair()
+
+        envelope_json = json.dumps(envelope, sort_keys=True)
+        envelope_bytes = envelope_json.encode("utf-8")
+        signature_bytes = keypair.sign(envelope_bytes)
+        signature_hex = signature_bytes.hex()
+        return {
+            "agent": self.did,
+            "envelope": envelope,
+            "signature": signature_hex,
+        }
+
+    # ---------- verification ----------
+
+    def verify_envelope(
+        self,
+        signer_did: str,
+        envelope: Dict[str, Any],
+        signature: str,
+        timeout: Optional[float] = None,
+    ) -> bool:
+        envelope_json = json.dumps(envelope, sort_keys=True)
+        message_bytes = envelope_json.encode("utf-8")
+
+        try:
+            signature_bytes = bytes.fromhex(signature)
+        except ValueError:
+            print("⚠️ verify_envelope: invalid hex signature string")
+            return False
+
+        try:
+            is_valid = online_signature_verify(
+                rubixNodeBaseUrl=self.base_url,
+                did=signer_did,
+                message=message_bytes,
+                signature=signature_bytes,
+            )
+            return bool(is_valid)
+        except signatureResponseError as e:
+            print(f"⚠️ verify_envelope error: {e}")
+            return False
+
+    def verify_message_payload(
+        self,
+        raw_text: str,
+        mode: str = "light",
+    ) -> Dict[str, Any]:
+        effective_mode = (mode or os.getenv("AGENTDNA_VERIFY_MODE") or "light").lower()
+
+        result: Dict[str, Any] = {
+            "original_message": raw_text,
+            "host_block": None,
+            "host_ok": None,
+            "trust_issues": [],
+            "agent_checks": [],
+            "verified": False,      # final overall flag
+        }
+
+        if not raw_text:
+            return result
+
+        try:
+            payload = json.loads(raw_text)
+        except Exception:
+            # plain text: nothing to verify
+            return result
+
+        if not isinstance(payload, dict):
+            return result
+
+        host_block = None
+
+        if "host" in payload and isinstance(payload["host"], dict):
+            host_block = payload["host"]
+        elif all(k in payload for k in ("agent", "envelope", "signature")):
+            host_block = payload
+
+        result["host_block"] = host_block
+
+        env = None
+        if isinstance(host_block, dict):
+            env = host_block.get("envelope", {})
+            if isinstance(env, dict):
+                orig = env.get("original_message")
+                if isinstance(orig, str):
+                    result["original_message"] = orig
+
+        # Start optimistic and flip to False when something fails
+        overall_ok = True
+
+        # ---- Host verification (always done) ----
+        if isinstance(host_block, dict) and isinstance(env, dict):
+            signer_did = host_block.get("agent")
+            sig = host_block.get("signature")
+
+            if signer_did and sig:
+                ok = self.verify_envelope(signer_did, env, sig)
+                result["host_ok"] = bool(ok)
+                if not ok:
+                    overall_ok = False
+                    result["trust_issues"].append(
+                        f"Invalid host signature for DID {signer_did}"
+                    )
+            else:
+                overall_ok = False
+                result["trust_issues"].append(
+                    "Host block missing agent/envelope/signature"
+                )
+        else:
+            overall_ok = False
+            result["trust_issues"].append("No host block found in payload")
+
+        # ---- Agent verification (heavy mode) ----
+        if effective_mode == "heavy":
+            agent_blocks: List[Dict[str, Any]] = []
+
+            if "agent" in payload and isinstance(payload["agent"], dict):
+                agent_blocks.append(payload["agent"])
+
+            responses = payload.get("responses")
+            if isinstance(responses, list):
+                for r in responses:
+                    if isinstance(r, dict):
+                        agent_blocks.append(r)
+
+            for ab in agent_blocks:
+                a_env = ab.get("envelope", {})
+                a_sig = ab.get("signature")
+                a_did = ab.get("agent")
+
+                if not (a_did and a_sig and isinstance(a_env, dict)):
+                    overall_ok = False
+                    result["agent_checks"].append(
+                        {
+                            "agent": a_did or "<unknown>",
+                            "ok": False,
+                            "envelope": a_env if isinstance(a_env, dict) else {},
+                            "reason": "Agent block missing agent/envelope/signature",
+                        }
+                    )
+                    result["trust_issues"].append(
+                        "Agent block missing agent/envelope/signature"
+                    )
+                    continue
+
+                ok = self.verify_envelope(a_did, a_env, a_sig)
+                result["agent_checks"].append(
+                    {
+                        "agent": a_did,
+                        "ok": bool(ok),
+                        "envelope": a_env,
+                        "reason": None if ok else "Agent signature invalid",
+                    }
+                )
+                if not ok:
+                    overall_ok = False
+                    result["trust_issues"].append(
+                        f"Invalid signature from agent {a_did}"
+                    )
+
+        result["verified"] = overall_ok
+        return result