halyn 1.0.0__tar.gz → 2.0.0__tar.gz

halyn-2.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Elmadani SALKA
+
+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.

halyn-2.0.0/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: halyn
+Version: 2.0.0
+Summary: Halyn — AAP in action. AI agents that can prove what they did.
+License: MIT
+Project-URL: Homepage, https://halyn.dev
+Project-URL: Repository, https://github.com/ElmadaniS/halyn
+Keywords: halyn,aap,agent,accountability,ai,safety
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aap-protocol>=0.1.0
+Requires-Dist: nrprotocol>=0.1.0
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
+Dynamic: license-file
+
+<div align="center">
+
+# Halyn
+
+**AAP in action. AI agents that can prove what they did.**
+
+[![PyPI](https://img.shields.io/pypi/v/halyn?color=0a6e3f)](https://pypi.org/project/halyn/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-0a6e3f.svg)](LICENSE)
+[![Tests](https://img.shields.io/badge/tests-9%20passed-0a6e3f.svg)](tests/)
+
+The reference implementation of [AAP — Agent Accountability Protocol](https://aap-protocol.dev)
+
+[Website](https://halyn.dev) · [AAP Spec](https://aap-protocol.dev) · [NRP](https://nrprotocol.dev)
+
+</div>
+
+---
+
+## What is Halyn?
+
+Halyn is the complete demonstration of [AAP](https://aap-protocol.dev).
+
+Every agent action goes through 7 steps — none skippable:
+
+```
+Identity → Authorization → Scope → Shield → Execute → Provenance → Audit
+```
+
+```python
+from halyn import HalynControlPlane, ExecutionContext
+from aap import AAPKeyPair, AAPIdentity, AAPAuthorization, AuthorizationLevel
+
+# Setup
+supervisor = AAPKeyPair.generate()
+cp = HalynControlPlane(supervisor_keypair=supervisor, supervisor_did="did:key:z6Mk...")
+
+# Register agent + node
+cp.register_identity(identity)
+cp.register_node(node)
+auth = cp.grant_authorization(agent_id=..., level=AuthorizationLevel.SUPERVISED, scope=["write:file"])
+
+# Execute — full AAP pipeline, fully audited
+ctx = ExecutionContext(identity=identity, authorization=auth, agent_keypair=agent_kp)
+result = cp.execute(ctx, node_id="nrp://acme/server/files-1", action="write:file", params={...})
+
+# Verify audit chain integrity
+valid, count, broken = cp.verify_audit()
+```
+
+## AAP Ecosystem
+
+| Layer | Project | Role |
+|-------|---------|------|
+| Spec | [AAP](https://aap-protocol.dev) | Protocol definition |
+| Physical | [NRP](https://nrprotocol.dev) | AAP for robots, IoT, machines |
+| Full system | **Halyn** (this) | Complete demonstration |
+
+## License
+
+MIT

halyn-2.0.0/README.md

@@ -0,0 +1,60 @@
+<div align="center">
+
+# Halyn
+
+**AAP in action. AI agents that can prove what they did.**
+
+[![PyPI](https://img.shields.io/pypi/v/halyn?color=0a6e3f)](https://pypi.org/project/halyn/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-0a6e3f.svg)](LICENSE)
+[![Tests](https://img.shields.io/badge/tests-9%20passed-0a6e3f.svg)](tests/)
+
+The reference implementation of [AAP — Agent Accountability Protocol](https://aap-protocol.dev)
+
+[Website](https://halyn.dev) · [AAP Spec](https://aap-protocol.dev) · [NRP](https://nrprotocol.dev)
+
+</div>
+
+---
+
+## What is Halyn?
+
+Halyn is the complete demonstration of [AAP](https://aap-protocol.dev).
+
+Every agent action goes through 7 steps — none skippable:
+
+```
+Identity → Authorization → Scope → Shield → Execute → Provenance → Audit
+```
+
+```python
+from halyn import HalynControlPlane, ExecutionContext
+from aap import AAPKeyPair, AAPIdentity, AAPAuthorization, AuthorizationLevel
+
+# Setup
+supervisor = AAPKeyPair.generate()
+cp = HalynControlPlane(supervisor_keypair=supervisor, supervisor_did="did:key:z6Mk...")
+
+# Register agent + node
+cp.register_identity(identity)
+cp.register_node(node)
+auth = cp.grant_authorization(agent_id=..., level=AuthorizationLevel.SUPERVISED, scope=["write:file"])
+
+# Execute — full AAP pipeline, fully audited
+ctx = ExecutionContext(identity=identity, authorization=auth, agent_keypair=agent_kp)
+result = cp.execute(ctx, node_id="nrp://acme/server/files-1", action="write:file", params={...})
+
+# Verify audit chain integrity
+valid, count, broken = cp.verify_audit()
+```
+
+## AAP Ecosystem
+
+| Layer | Project | Role |
+|-------|---------|------|
+| Spec | [AAP](https://aap-protocol.dev) | Protocol definition |
+| Physical | [NRP](https://nrprotocol.dev) | AAP for robots, IoT, machines |
+| Full system | **Halyn** (this) | Complete demonstration |
+
+## License
+
+MIT

halyn-2.0.0/halyn/__init__.py

@@ -0,0 +1,15 @@
+"""
+Halyn — AAP in action. AI agents that can prove what they did.
+
+The reference implementation of AAP — Agent Accountability Protocol.
+https://halyn.dev | https://aap-protocol.dev
+License: MIT
+"""
+import sys
+sys.path.insert(0, "/mnt/data/aap/sdk/python")
+sys.path.insert(0, "/mnt/data/nrp-new")
+
+from .core import HalynControlPlane, ExecutionContext, ExecutionResult
+
+__version__ = "1.0.0"
+__all__ = ["HalynControlPlane", "ExecutionContext", "ExecutionResult"]

halyn-2.0.0/halyn/core.py

@@ -0,0 +1,238 @@
+"""
+Halyn ControlPlane — the full AAP implementation.
+Orchestrates: Identity → Authorization → Execution → Provenance → Audit
+"""
+from __future__ import annotations
+import sys
+sys.path.insert(0, "/mnt/data/aap/sdk/python")
+sys.path.insert(0, "/mnt/data/nrp-new")
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any
+
+from aap import (
+    AAPIdentity, AAPKeyPair, AAPAuthorization, AuthorizationLevel,
+    AAPProvenance, AAPAuditChain,
+    AAPPhysicalWorldViolation, AAPScopeError, AAPRevocationError,
+)
+from nrp import NRPNode, ShieldViolation
+
+
+@dataclass
+class ExecutionContext:
+    """Full context for a single agent action — identity + authorization."""
+    identity: AAPIdentity
+    authorization: AAPAuthorization
+    agent_keypair: AAPKeyPair
+
+    def check(self) -> None:
+        """Validate context before any action."""
+        if self.identity.revoked:
+            raise AAPRevocationError(f"Identity {self.identity.id} is revoked")
+        self.authorization.check()
+
+    @property
+    def agent_id(self) -> str:
+        return self.identity.id
+
+    @property
+    def auth_level(self) -> AuthorizationLevel:
+        return self.authorization.level
+
+
+@dataclass
+class ExecutionResult:
+    """Result of a Halyn-mediated action."""
+    success: bool
+    agent_id: str
+    action: str
+    node_id: str | None
+    output: Any
+    provenance_id: str | None
+    audit_entry_id: str | None
+    blocked: bool = False
+    block_reason: str | None = None
+    detail: str | None = None
+
+
+class HalynControlPlane:
+    """
+    AAP reference implementation — full system.
+
+    Flow for every action:
+    1. IDENTITY   — verify agent exists and is not revoked
+    2. AUTHORIZATION — verify agent has permission at correct level
+    3. SCOPE      — verify action is within authorized scope
+    4. SHIELD     — verify NRP shield rules (physical nodes only)
+    5. EXECUTE    — run the action
+    6. PROVENANCE — record what was produced
+    7. AUDIT      — append to tamper-evident chain
+    """
+
+    def __init__(
+        self,
+        supervisor_keypair: AAPKeyPair,
+        supervisor_did: str,
+        audit_path: str | None = None,
+    ) -> None:
+        self._supervisor_keypair = supervisor_keypair
+        self._supervisor_did = supervisor_did
+        self._identities: dict[str, AAPIdentity] = {}
+        self._nodes: dict[str, NRPNode] = {}
+        self._audit = AAPAuditChain(
+            storage_path=__import__("pathlib").Path(audit_path) if audit_path else None
+        )
+
+    # ── Registration ──────────────────────────────────────────────────────────
+
+    def register_identity(self, identity: AAPIdentity) -> None:
+        """Register a known agent identity."""
+        self._identities[identity.id] = identity
+
+    def register_node(self, node: NRPNode) -> None:
+        """Register a physical or digital node."""
+        self._nodes[node.id] = node
+
+    def grant_authorization(
+        self,
+        agent_id: str,
+        level: AuthorizationLevel,
+        scope: list[str],
+        physical: bool = False,
+        expires_in_seconds: int | None = None,
+    ) -> AAPAuthorization:
+        """
+        Grant authorization to a registered agent.
+        Enforces Physical World Rule automatically.
+        """
+        expires_at = None
+        if expires_in_seconds is not None:
+            from datetime import timedelta
+            expires_at = datetime.now(timezone.utc) + timedelta(seconds=expires_in_seconds)
+
+        return AAPAuthorization.create(
+            agent_id=agent_id,
+            level=level,
+            scope=scope,
+            supervisor_keypair=self._supervisor_keypair,
+            supervisor_did=self._supervisor_did,
+            physical=physical,
+            expires_at=expires_at,
+        )
+
+    # ── Execution ──────────────────────────────────────────────────────────────
+
+    def execute(
+        self,
+        ctx: ExecutionContext,
+        node_id: str,
+        action: str,
+        params: dict[str, Any],
+        input_description: str = "",
+    ) -> ExecutionResult:
+        """
+        Execute an action through the full AAP pipeline.
+        Every step is recorded. Nothing is skipped.
+        """
+        # 1. Identity + Authorization check
+        try:
+            ctx.check()
+        except (AAPRevocationError, Exception) as e:
+            return self._blocked(ctx.agent_id, action, node_id, str(e))
+
+        # 2. Scope check
+        if not ctx.identity.allows_action(action):
+            return self._blocked(
+                ctx.agent_id, action, node_id,
+                f"Action '{action}' not in agent scope: {ctx.identity.scope}"
+            )
+
+        # 3. Get node
+        node = self._nodes.get(node_id)
+        if node is None:
+            return self._blocked(ctx.agent_id, action, node_id, f"Node {node_id!r} not registered")
+
+        # 4. Shield check + Execute
+        try:
+            node_result = node.execute(action, params)
+        except ShieldViolation as e:
+            # Shield blocked — still record to audit
+            prov = AAPProvenance.create(
+                agent_id=ctx.agent_id,
+                action=action,
+                input_data=str(params).encode(),
+                output_data=b"blocked",
+                authorization_id=ctx.authorization.session_id,
+                agent_keypair=ctx.agent_keypair,
+                target=node_id,
+            )
+            entry = self._audit.append(
+                agent_id=ctx.agent_id,
+                action=action,
+                result="blocked",
+                provenance_id=prov.artifact_id,
+                agent_keypair=ctx.agent_keypair,
+                authorization_level=int(ctx.auth_level),
+                physical=node.is_physical,
+                result_detail=str(e),
+            )
+            return ExecutionResult(
+                success=False, agent_id=ctx.agent_id, action=action,
+                node_id=node_id, output=None,
+                provenance_id=prov.artifact_id,
+                audit_entry_id=entry.entry_id,
+                blocked=True, block_reason=str(e),
+            )
+
+        # 5. Provenance
+        prov = AAPProvenance.create(
+            agent_id=ctx.agent_id,
+            action=action,
+            input_data=str(params).encode(),
+            output_data=str(node_result.output).encode(),
+            authorization_id=ctx.authorization.session_id,
+            agent_keypair=ctx.agent_keypair,
+            target=node_id,
+        )
+
+        # 6. Audit
+        result_str = "success" if node_result.success else "failure"
+        entry = self._audit.append(
+            agent_id=ctx.agent_id,
+            action=action,
+            result=result_str,
+            provenance_id=prov.artifact_id,
+            agent_keypair=ctx.agent_keypair,
+            authorization_level=int(ctx.auth_level),
+            physical=node.is_physical,
+        )
+
+        return ExecutionResult(
+            success=node_result.success,
+            agent_id=ctx.agent_id,
+            action=action,
+            node_id=node_id,
+            output=node_result.output,
+            provenance_id=prov.artifact_id,
+            audit_entry_id=entry.entry_id,
+            detail=node_result.detail,
+        )
+
+    def verify_audit(self) -> tuple[bool, int, str | None]:
+        """Verify the audit chain integrity."""
+        return self._audit.verify()
+
+    def audit_entries(self) -> list[dict]:
+        """Export full audit log."""
+        return self._audit.to_list()
+
+    # ── Internal ──────────────────────────────────────────────────────────────
+
+    def _blocked(self, agent_id, action, node_id, reason) -> ExecutionResult:
+        return ExecutionResult(
+            success=False, agent_id=agent_id, action=action,
+            node_id=node_id, output=None,
+            provenance_id=None, audit_entry_id=None,
+            blocked=True, block_reason=reason,
+        )

halyn-2.0.0/halyn.egg-info/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: halyn
+Version: 2.0.0
+Summary: Halyn — AAP in action. AI agents that can prove what they did.
+License: MIT
+Project-URL: Homepage, https://halyn.dev
+Project-URL: Repository, https://github.com/ElmadaniS/halyn
+Keywords: halyn,aap,agent,accountability,ai,safety
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aap-protocol>=0.1.0
+Requires-Dist: nrprotocol>=0.1.0
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
+Dynamic: license-file
+
+<div align="center">
+
+# Halyn
+
+**AAP in action. AI agents that can prove what they did.**
+
+[![PyPI](https://img.shields.io/pypi/v/halyn?color=0a6e3f)](https://pypi.org/project/halyn/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-0a6e3f.svg)](LICENSE)
+[![Tests](https://img.shields.io/badge/tests-9%20passed-0a6e3f.svg)](tests/)
+
+The reference implementation of [AAP — Agent Accountability Protocol](https://aap-protocol.dev)
+
+[Website](https://halyn.dev) · [AAP Spec](https://aap-protocol.dev) · [NRP](https://nrprotocol.dev)
+
+</div>
+
+---
+
+## What is Halyn?
+
+Halyn is the complete demonstration of [AAP](https://aap-protocol.dev).
+
+Every agent action goes through 7 steps — none skippable:
+
+```
+Identity → Authorization → Scope → Shield → Execute → Provenance → Audit
+```
+
+```python
+from halyn import HalynControlPlane, ExecutionContext
+from aap import AAPKeyPair, AAPIdentity, AAPAuthorization, AuthorizationLevel
+
+# Setup
+supervisor = AAPKeyPair.generate()
+cp = HalynControlPlane(supervisor_keypair=supervisor, supervisor_did="did:key:z6Mk...")
+
+# Register agent + node
+cp.register_identity(identity)
+cp.register_node(node)
+auth = cp.grant_authorization(agent_id=..., level=AuthorizationLevel.SUPERVISED, scope=["write:file"])
+
+# Execute — full AAP pipeline, fully audited
+ctx = ExecutionContext(identity=identity, authorization=auth, agent_keypair=agent_kp)
+result = cp.execute(ctx, node_id="nrp://acme/server/files-1", action="write:file", params={...})
+
+# Verify audit chain integrity
+valid, count, broken = cp.verify_audit()
+```
+
+## AAP Ecosystem
+
+| Layer | Project | Role |
+|-------|---------|------|
+| Spec | [AAP](https://aap-protocol.dev) | Protocol definition |
+| Physical | [NRP](https://nrprotocol.dev) | AAP for robots, IoT, machines |
+| Full system | **Halyn** (this) | Complete demonstration |
+
+## License
+
+MIT

halyn-2.0.0/halyn.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+halyn/__init__.py
+halyn/core.py
+halyn.egg-info/PKG-INFO
+halyn.egg-info/SOURCES.txt
+halyn.egg-info/dependency_links.txt
+halyn.egg-info/requires.txt
+halyn.egg-info/top_level.txt
+tests/test_halyn.py

halyn-2.0.0/halyn.egg-info/requires.txt

@@ -0,0 +1,5 @@
+aap-protocol>=0.1.0
+nrprotocol>=0.1.0
+
+[test]
+pytest>=8.0

halyn-2.0.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "halyn"
+version = "2.0.0"
+description = "Halyn — AAP in action. AI agents that can prove what they did."
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.11"
+dependencies = ["aap-protocol>=0.1.0", "nrprotocol>=0.1.0"]
+keywords = ["halyn", "aap", "agent", "accountability", "ai", "safety"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.11",
+]
+[project.urls]
+Homepage = "https://halyn.dev"
+Repository = "https://github.com/ElmadaniS/halyn"
+
+[project.optional-dependencies]
+test = ["pytest>=8.0"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-v --tb=short"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["halyn*"]