agent-dna 0.1.0__tar.gz

agent_dna-0.1.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,127 @@
+
+# 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/agent_dna.egg-info/PKG-INFO

@@ -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/agent_dna.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+agent_dna.egg-info/PKG-INFO
+agent_dna.egg-info/SOURCES.txt
+agent_dna.egg-info/dependency_links.txt
+agent_dna.egg-info/requires.txt
+agent_dna.egg-info/top_level.txt
+agentdna/__init__.py
+agentdna/core.py
+agentdna/handler.py
+agentdna/node_client.py
+agentdna/token.txt
+agentdna/trust.py

agent_dna-0.1.0/agent_dna.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agent_dna-0.1.0/agent_dna.egg-info/requires.txt

@@ -0,0 +1,3 @@
+requests>=2.0.0
+python-dotenv>=1.0.0
+rubix-py

agent_dna-0.1.0/agent_dna.egg-info/top_level.txt

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

agent_dna-0.1.0/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"
+]

agent_dna-0.1.0/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,
+        )