halyn 2.1.2__tar.gz → 2.2.0__tar.gz

{halyn-2.1.2/src/halyn.egg-info → halyn-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: halyn
-Version: 2.1.2
+Version: 2.2.0
 Summary: Halyn — The governance layer for AI agents. Every action intercepted. Every decision auditable.
 Author-email: Elmadani SALKA <contact@halyn.dev>
 License: BSL-1.1
@@ -20,7 +20,6 @@ Classifier: Topic :: Security
 Classifier: Topic :: System :: Systems Administration
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-License-File: LICENSE
 Requires-Dist: aiohttp>=3.9
 Provides-Extra: iot
 Requires-Dist: paho-mqtt; extra == "iot"
@@ -29,7 +28,6 @@ Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-asyncio; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
-Dynamic: license-file
 
 <div align="center">
 
@@ -80,19 +78,21 @@ Every action produces a cryptographic proof stored locally. Not in the cloud. No
 
 ## Install
 
+**Option 1 — pip** (Python 3.10+):
+
 ```bash
-pip install halyn
+pip install halyn==2.1.3
 halyn serve
 ```
 
-Opens the dashboard at `http://localhost:7420`. Nothing leaves your machine.
+**Option 2 — curl** (Linux / macOS):
 
 ```bash
-# Or with curl
 curl -fsSL https://halyn.dev/install | bash
 ```
 
-The install script tells you exactly what it will do before doing anything.
+Both options open the dashboard at `http://localhost:7420`. Nothing leaves your machine.
+The curl script verifies your Python version and asks permission before doing anything.
 
 ---
 
@@ -175,7 +175,7 @@ This means: if an AI agent makes an API call or accesses your system, Halyn sees
 | Provider | Models (March 2026) | API |
 |----------|---------------------|-----|
 | **Anthropic** | Claude Sonnet 4.6, Claude Opus 4.6, Claude Haiku 4.5 | api.anthropic.com |
-| **OpenAI** | GPT-4.1, GPT-4.1 mini, GPT-4.1 nano, o3, o4-mini | api.openai.com |
+| **OpenAI** | GPT| api.openai.com |
 | **Google** | Gemini 3.1 Pro, Gemini 3.1 Flash, Gemini 3.1 Flash-Lite | generativelanguage.googleapis.com |
 | **Mistral AI** | Mistral Large 2, Mistral Small 3, Codestral | api.mistral.ai |
 | **xAI** | Grok-3, Grok-3 mini | api.x.ai |

{halyn-2.1.2 → halyn-2.2.0}/README.md

@@ -47,19 +47,21 @@ Every action produces a cryptographic proof stored locally. Not in the cloud. No
 
 ## Install
 
+**Option 1 — pip** (Python 3.10+):
+
 ```bash
-pip install halyn
+pip install halyn==2.1.3
 halyn serve
 ```
 
-Opens the dashboard at `http://localhost:7420`. Nothing leaves your machine.
+**Option 2 — curl** (Linux / macOS):
 
 ```bash
-# Or with curl
 curl -fsSL https://halyn.dev/install | bash
 ```
 
-The install script tells you exactly what it will do before doing anything.
+Both options open the dashboard at `http://localhost:7420`. Nothing leaves your machine.
+The curl script verifies your Python version and asks permission before doing anything.
 
 ---
 
@@ -142,7 +144,7 @@ This means: if an AI agent makes an API call or accesses your system, Halyn sees
 | Provider | Models (March 2026) | API |
 |----------|---------------------|-----|
 | **Anthropic** | Claude Sonnet 4.6, Claude Opus 4.6, Claude Haiku 4.5 | api.anthropic.com |
-| **OpenAI** | GPT-4.1, GPT-4.1 mini, GPT-4.1 nano, o3, o4-mini | api.openai.com |
+| **OpenAI** | GPT| api.openai.com |
 | **Google** | Gemini 3.1 Pro, Gemini 3.1 Flash, Gemini 3.1 Flash-Lite | generativelanguage.googleapis.com |
 | **Mistral AI** | Mistral Large 2, Mistral Small 3, Codestral | api.mistral.ai |
 | **xAI** | Grok-3, Grok-3 mini | api.x.ai |

{halyn-2.1.2 → halyn-2.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "halyn"
-version = "2.1.2"
+version = "2.2.0"
 description = "Halyn — The governance layer for AI agents. Every action intercepted. Every decision auditable."
 requires-python = ">=3.10"
 license = {text = "BSL-1.1"}
@@ -38,6 +38,9 @@ Changelog     = "https://github.com/halyndev/halyn/blob/main/CHANGELOG.md"
 [project.scripts]
 halyn = "halyn.cli:main"
 
+[tool.setuptools]
+license-files = []
+
 [tool.setuptools.packages.find]
 where = ["src"]
 

{halyn-2.1.2 → halyn-2.2.0}/src/halyn/__init__.py

@@ -9,7 +9,7 @@ Every action intercepted. Every decision auditable.
 The AI cannot bypass it.
 """
 
-__version__ = "2.1.2"
+__version__ = "2.1.3"
 __author__ = "Elmadani SALKA"
 __license__ = "BSL-1.1"
 __email__ = "contact@halyn.dev"

halyn-2.2.0/src/halyn/_nrp/__init__.py

@@ -0,0 +1,17 @@
+# Copyright (c) 2026 Elmadani SALKA
+# NRP SDK bundled inside halyn — standalone distribution.
+# External imports remain compatible: `from nrp import ...`
+# Internal imports use: `from halyn._nrp import ...`
+
+from .identity import NRPId
+from .manifest import NRPManifest, ChannelSpec, ActionSpec, ShieldSpec
+from .events import NRPEvent, EventBus, EventSSE, Severity
+from .driver import NRPDriver, ShieldRule, ShieldType
+
+__version__ = "0.1.0"
+__all__ = [
+    "NRPId",
+    "NRPManifest", "ChannelSpec", "ActionSpec", "ShieldSpec",
+    "NRPEvent", "EventBus", "EventSSE", "Severity",
+    "NRPDriver", "ShieldRule", "ShieldType",
+]

halyn-2.2.0/src/halyn/_nrp/driver.py

@@ -0,0 +1,112 @@
+# Copyright (c) 2026 Elmadani SALKA. 
+# Licensed under the  See LICENSE file.
+"""
+NRP Driver v2 — Universal interface with Manifest + Events.
+
+Every device implements:
+  manifest()  — declare what you are and what you can do
+  observe()   — read state
+  act()       — change state
+  on_event()  — push events to the control plane
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Callable, Awaitable
+
+from .identity import NRPId
+from .manifest import NRPManifest, ChannelSpec, ActionSpec, ShieldSpec
+from .events import NRPEvent, EventBus, Severity
+
+
+class ShieldType(str, Enum):
+    LIMIT = "limit"
+    ZONE = "zone"
+    THRESHOLD = "threshold"
+    PATTERN = "pattern"
+    COMMAND = "command"
+    CONFIRM = "confirm"
+
+
+@dataclass(frozen=True, slots=True)
+class ShieldRule:
+    name: str
+    type: ShieldType
+    value: Any = None
+    unit: str = ""
+    description: str = ""
+
+
+class NRPDriver(ABC):
+    """
+    Base class for all NRP drivers.
+    
+    Implement this to connect ANY device to AI.
+    Subclass and implement manifest(), observe(), act(), shield_rules().
+    """
+
+    def __init__(self) -> None:
+        self._event_bus: EventBus | None = None
+        self._nrp_id: NRPId | None = None
+
+    def bind(self, nrp_id: NRPId, event_bus: EventBus) -> None:
+        """Called by NRP Bridge at registration. Gives driver access to events."""
+        self._nrp_id = nrp_id
+        self._event_bus = event_bus
+
+    # ─── The 4 core methods ─────────────────────────
+
+    @abstractmethod
+    def manifest(self) -> NRPManifest:
+        """Declare everything about this node. Called once at registration."""
+
+    @abstractmethod
+    async def observe(self, channels: list[str] | None = None) -> dict[str, Any]:
+        """Read node state. Returns {channel_name: data}."""
+
+    @abstractmethod
+    async def act(self, command: str, args: dict[str, Any]) -> Any:
+        """Execute a command. Returns result."""
+
+    @abstractmethod
+    def shield_rules(self) -> list[ShieldRule]:
+        """Safety limits. Enforced by control plane."""
+
+    # ─── Events ─────────────────────────────────────
+
+    async def emit(self, name: str, severity: str = Severity.INFO, **data: Any) -> None:
+        """Push an event to the control plane."""
+        if self._event_bus and self._nrp_id:
+            event = NRPEvent(
+                source=self._nrp_id.uri,
+                name=name,
+                severity=severity,
+                data=data,
+            )
+            await self._event_bus.emit(event)
+
+    async def emit_emergency(self, name: str, **data: Any) -> None:
+        """Push an emergency event. Bypasses all queues."""
+        await self.emit(name, Severity.EMERGENCY, **data)
+
+    # ─── Lifecycle ──────────────────────────────────
+
+    async def connect(self) -> bool:
+        """Establish connection. Override for networked devices."""
+        return True
+
+    async def disconnect(self) -> None:
+        """Clean shutdown."""
+        pass
+
+    async def heartbeat(self) -> dict[str, Any]:
+        """Health check."""
+        try:
+            state = await self.observe(["status"])
+            return {"alive": True, **state}
+        except Exception as e:
+            return {"alive": False, "error": str(e)[:200]}
+

halyn-2.2.0/src/halyn/_nrp/events.py

@@ -0,0 +1,234 @@
+# Copyright (c) 2026 Elmadani SALKA. 
+# Licensed under the  See LICENSE file.
+"""
+NRP Events — Asynchronous event bus with severity-based routing.
+
+Nodes emit events. The control plane dispatches to subscribers
+based on pattern matching. Emergency events bypass the queue.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import time
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import Any, Callable, Awaitable
+
+log = logging.getLogger("jarvis.events")
+
+EventHandler = Callable[["NRPEvent"], Awaitable[None] | None]
+
+
+class Severity:
+    """Event severity levels."""
+    DEBUG = "debug"
+    INFO = "info"
+    WARNING = "warning"
+    CRITICAL = "critical"
+    EMERGENCY = "emergency"  # Bypasses all queues
+
+
+@dataclass(frozen=True, slots=True)
+class NRPEvent:
+    """Single event payload."""
+    source: str          # NRP ID or node name
+    name: str            # "temperature_changed", "battery_low", "collision"
+    severity: str        # Severity level
+    data: dict[str, Any] = field(default_factory=dict)
+    timestamp: float = field(default_factory=time.time)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "source": self.source,
+            "name": self.name,
+            "severity": self.severity,
+            "data": self.data,
+            "timestamp": self.timestamp,
+        }
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict(), default=str, ensure_ascii=False)
+
+
+class EventBus:
+    """Central event routing. Subscribe by pattern, receive matching events."""
+
+    __slots__ = ("_handlers", "_history", "_max_history", "_queue")
+
+    def __init__(self, max_history: int = 10_000) -> None:
+        self._handlers: dict[str, list[EventHandler]] = defaultdict(list)
+        self._history: list[NRPEvent] = []
+        self._max_history = max_history
+        self._queue: asyncio.Queue[NRPEvent] = asyncio.Queue(maxsize=50_000)
+
+    def subscribe(self, pattern: str, handler: EventHandler) -> None:
+        """
+        Subscribe to events matching a pattern.
+
+        Patterns:
+          "*"                    — all events
+          "battery_low"          — exact event name
+          "nrp://farm/*"         — all events from farm scope
+          "temperature_*"        — wildcard on event name
+        """
+        self._handlers[pattern].append(handler)
+        log.debug("events.subscribe pattern=%s", pattern)
+
+    def unsubscribe(self, pattern: str, handler: EventHandler) -> None:
+        if pattern in self._handlers:
+            self._handlers[pattern] = [h for h in self._handlers[pattern] if h is not handler]
+
+    async def emit(self, event: NRPEvent) -> int:
+        """
+        Emit an event. Routes to all matching handlers.
+        Returns number of handlers that received it.
+
+        EMERGENCY events are processed synchronously (no queue).
+        All others go through the async queue.
+        """
+        self._record(event)
+
+        if event.severity == Severity.EMERGENCY:
+            return await self._dispatch_now(event)
+
+        try:
+            self._queue.put_nowait(event)
+        except asyncio.QueueFull:
+            log.error("events.queue_full dropping=%s", event.name)
+        return 0  # Will be dispatched by process_loop
+
+    async def emit_simple(
+        self, source: str, name: str, severity: str = Severity.INFO, **data: Any
+    ) -> int:
+        """Shorthand for emitting events."""
+        return await self.emit(NRPEvent(source=source, name=name, severity=severity, data=data))
+
+    async def process_loop(self) -> None:
+        """Background loop that processes queued events. Run as asyncio task."""
+        log.info("events.loop_started")
+        while True:
+            try:
+                event = await asyncio.wait_for(self._queue.get(), timeout=1.0)
+                await self._dispatch_now(event)
+            except asyncio.TimeoutError:
+                continue
+            except Exception as exc:
+                log.exception("events.loop_error: %s", exc)
+
+    def recent(self, n: int = 50, source: str = "", name: str = "", severity: str = "") -> list[NRPEvent]:
+        """Query recent events with optional filters."""
+        events = self._history
+        if source:
+            events = [e for e in events if source in e.source]
+        if name:
+            events = [e for e in events if name in e.name]
+        if severity:
+            events = [e for e in events if e.severity == severity]
+        return events[-n:]
+
+    @property
+    def pending(self) -> int:
+        return self._queue.qsize()
+
+    @property
+    def total(self) -> int:
+        return len(self._history)
+
+    # ─── Internal ──────────────────────────────────
+
+    async def _dispatch_now(self, event: NRPEvent) -> int:
+        """Dispatch to all matching handlers immediately."""
+        import fnmatch
+        count = 0
+        for pattern, handlers in self._handlers.items():
+            matched = (
+                pattern == "*"
+                or pattern == event.name
+                or fnmatch.fnmatch(event.name, pattern)
+                or fnmatch.fnmatch(event.source, pattern)
+            )
+            if matched:
+                for handler in handlers:
+                    try:
+                        result = handler(event)
+                        if asyncio.iscoroutine(result):
+                            await result
+                        count += 1
+                    except Exception as exc:
+                        log.error("events.handler_error pattern=%s error=%s", pattern, exc)
+        return count
+
+    def _record(self, event: NRPEvent) -> None:
+        """Store in history ring buffer."""
+        self._history.append(event)
+        if len(self._history) > self._max_history:
+            self._history = self._history[-self._max_history // 2:]
+
+        lvl = {
+            Severity.DEBUG: logging.DEBUG,
+            Severity.INFO: logging.INFO,
+            Severity.WARNING: logging.WARNING,
+            Severity.CRITICAL: logging.ERROR,
+            Severity.EMERGENCY: logging.CRITICAL,
+        }.get(event.severity, logging.INFO)
+        log.log(lvl, "event.%s source=%s data=%s", event.name, event.source, 
+                json.dumps(event.data, default=str)[:200])
+
+
+class EventSSE:
+    """Server-Sent Events endpoint. Streams events to HTTP clients in real-time."""
+
+    def __init__(self, bus: EventBus) -> None:
+        self.bus = bus
+        self._clients: list[asyncio.Queue[str]] = []
+
+    async def handler(self, request: Any) -> Any:
+        """aiohttp SSE handler. Each client gets a queue."""
+        from aiohttp import web
+        from aiohttp.web import StreamResponse
+
+        response = StreamResponse()
+        response.content_type = "text/event-stream"
+        response.headers["Cache-Control"] = "no-cache"
+        response.headers["X-Accel-Buffering"] = "no"
+        await response.prepare(request)
+
+        queue: asyncio.Queue[str] = asyncio.Queue(maxsize=1000)
+        self._clients.append(queue)
+
+        try:
+            while True:
+                try:
+                    data = await asyncio.wait_for(queue.get(), timeout=30.0)
+                    await response.write(f"data: {data}\n\n".encode())
+                except asyncio.TimeoutError:
+                    # Keepalive
+                    await response.write(b": keepalive\n\n")
+        except (ConnectionResetError, asyncio.CancelledError):
+            pass
+        finally:
+            self._clients.remove(queue)
+
+        return response
+
+    async def broadcast(self, event: NRPEvent) -> None:
+        """Send event to all SSE clients."""
+        data = event.to_json()
+        dead: list[asyncio.Queue[str]] = []
+        for client in self._clients:
+            try:
+                client.put_nowait(data)
+            except asyncio.QueueFull:
+                dead.append(client)
+        for d in dead:
+            self._clients.remove(d)
+
+    def wire(self, bus: EventBus) -> None:
+        """Subscribe to all events and broadcast to SSE clients."""
+        async def _forward(event: NRPEvent) -> None:
+            await self.broadcast(event)
+        bus.subscribe("*", _forward)
+

halyn-2.2.0/src/halyn/_nrp/identity.py

@@ -0,0 +1,88 @@
+# Copyright (c) 2026 Elmadani SALKA. 
+# Licensed under the  See LICENSE file.
+"""
+NRP Identity — Universal node addressing.
+
+Stable addressing: nrp://scope/kind/name
+Survives IP changes, network moves, device replacement.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+# nrp://factory-3/robot/arm-7
+# nrp://home/sensor/kitchen-temp
+# nrp://fleet/vehicle/truck-42
+# nrp://farm/drone/survey-1
+_NRP_PATTERN = re.compile(
+    r"^nrp://(?P<scope>[a-z0-9][a-z0-9._-]*)/"
+    r"(?P<kind>[a-z0-9][a-z0-9_-]*)/"
+    r"(?P<name>[a-z0-9][a-z0-9._-]*)$"
+)
+
+
+@dataclass(frozen=True, slots=True)
+class NRPId:
+    """Universal node identifier."""
+    scope: str    # Location/org: "factory-3", "home", "fleet", "farm"
+    kind: str     # Type: "robot", "sensor", "server", "vehicle", "drone"
+    name: str     # Instance: "arm-7", "kitchen-temp", "truck-42"
+
+    @property
+    def uri(self) -> str:
+        return f"nrp://{self.scope}/{self.kind}/{self.name}"
+
+    @property
+    def short(self) -> str:
+        """Short form for display: kind/name."""
+        return f"{self.kind}/{self.name}"
+
+    def matches(self, pattern: str) -> bool:
+        """Match against glob patterns. E.g. 'factory-*/robot/*'."""
+        import fnmatch
+        return fnmatch.fnmatch(self.uri, f"nrp://{pattern}")
+
+    @classmethod
+    def parse(cls, uri: str) -> NRPId:
+        """Parse 'nrp://scope/kind/name' into NRPId."""
+        m = _NRP_PATTERN.match(uri.lower().strip())
+        if not m:
+            raise ValueError(
+                f"Invalid NRP ID: {uri!r}. "
+                f"Format: nrp://scope/kind/name (lowercase, alphanumeric, hyphens)"
+            )
+        return cls(scope=m["scope"], kind=m["kind"], name=m["name"])
+
+    @classmethod
+    def create(cls, scope: str, kind: str, name: str) -> NRPId:
+        """Create and validate an NRP ID."""
+        nid = cls(scope=scope.lower(), kind=kind.lower(), name=name.lower())
+        # Validate by roundtripping through parse
+        NRPId.parse(nid.uri)
+        return nid
+
+
+    # Aliases for common naming conventions
+    @property
+    def domain(self) -> str:
+        """Alias for scope."""
+        return self.scope
+
+    @property
+    def device(self) -> str:
+        """Alias for kind."""
+        return self.kind
+
+    @property
+    def instance(self) -> str:
+        """Alias for name."""
+        return self.name
+
+    def __str__(self) -> str:
+        return self.uri
+
+    def __repr__(self) -> str:
+        return f"NRPId({self.uri!r})"
+

halyn-2.2.0/src/halyn/_nrp/manifest.py

@@ -0,0 +1,166 @@
+# Copyright (c) 2026 Elmadani SALKA. 
+# Licensed under the  See LICENSE file.
+"""
+NRP Manifest — Self-describing nodes.
+
+Structured capability declaration for NRP nodes.
+Channels (observe), actions (act), and constraints (shield)
+are declared once and consumed by any control plane.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from dataclasses import dataclass, field
+from typing import Any
+
+from .identity import NRPId
+
+
+@dataclass(slots=True)
+class ChannelSpec:
+    """One observable channel (sensor, metric, state)."""
+    name: str
+    type: str            # "float", "int", "bool", "string", "float[]", "image", "json"
+    unit: str = ""       # "°C", "rad", "m/s", "percent", "Pa", ""
+    rate: str = ""       # "100Hz", "1Hz", "on_change", "on_request"
+    description: str = ""
+    range: list[float] | None = None  # [min, max] if applicable
+
+    def to_dict(self) -> dict[str, Any]:
+        d: dict[str, Any] = {"name": self.name, "type": self.type}
+        if self.unit: d["unit"] = self.unit
+        if self.rate: d["rate"] = self.rate
+        if self.description: d["description"] = self.description
+        if self.range: d["range"] = self.range
+        return d
+
+
+@dataclass(slots=True)
+class ActionSpec:
+    """One action the node can perform."""
+    name: str
+    args: dict[str, str] = field(default_factory=dict)  # arg_name -> "type description"
+    description: str = ""
+    dangerous: bool = False
+    priority: str = "normal"  # "normal", "high", "critical"
+    returns: str = ""         # What it returns
+
+    def to_dict(self) -> dict[str, Any]:
+        d: dict[str, Any] = {"name": self.name}
+        if self.args: d["args"] = self.args
+        if self.description: d["description"] = self.description
+        if self.dangerous: d["dangerous"] = True
+        if self.priority != "normal": d["priority"] = self.priority
+        if self.returns: d["returns"] = self.returns
+        return d
+
+
+@dataclass(slots=True)
+class ShieldSpec:
+    """One safety constraint."""
+    name: str
+    type: str       # "limit", "zone", "threshold", "pattern", "confirm"
+    value: Any = None
+    unit: str = ""
+    description: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        d: dict[str, Any] = {"name": self.name, "type": self.type}
+        if self.value is not None: d["value"] = self.value
+        if self.unit: d["unit"] = self.unit
+        if self.description: d["description"] = self.description
+        return d
+
+
+@dataclass(slots=True)
+class NRPManifest:
+    """Complete capability descriptor for one NRP node."""
+
+    # Identity
+    nrp_id: NRPId
+    manufacturer: str = ""
+    model: str = ""
+    firmware: str = ""
+
+    # Capabilities
+    observe: list[ChannelSpec] = field(default_factory=list)
+    act: list[ActionSpec] = field(default_factory=list)
+    shield: list[ShieldSpec] = field(default_factory=list)
+
+    # Metadata
+    tags: dict[str, str] = field(default_factory=dict)
+    registered_at: float = field(default_factory=time.time)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "nrp_id": self.nrp_id.uri,
+            "manufacturer": self.manufacturer,
+            "model": self.model,
+            "firmware": self.firmware,
+            "observe": [c.to_dict() for c in self.observe],
+            "act": [a.to_dict() for a in self.act],
+            "shield": [s.to_dict() for s in self.shield],
+            "tags": self.tags,
+        }
+
+    def to_json(self, indent: int = 2) -> str:
+        return json.dumps(self.to_dict(), indent=indent, ensure_ascii=False)
+
+    def to_llm_description(self) -> str:
+        """Structured text summary suitable for LLM context injection."""
+        lines = [f"Node: {self.nrp_id.uri}"]
+        if self.manufacturer:
+            lines.append(f"  Device: {self.manufacturer} {self.model}")
+
+        if self.observe:
+            lines.append("  Observe (read state):")
+            for ch in self.observe:
+                unit = f" ({ch.unit})" if ch.unit else ""
+                desc = f" — {ch.description}" if ch.description else ""
+                lines.append(f"    {ch.name}: {ch.type}{unit}{desc}")
+
+        if self.act:
+            lines.append("  Act (commands):")
+            for a in self.act:
+                args_str = ", ".join(f"{k}: {v}" for k, v in a.args.items()) if a.args else "none"
+                danger = " [DANGEROUS]" if a.dangerous else ""
+                prio = f" [PRIORITY={a.priority}]" if a.priority != "normal" else ""
+                desc = f" — {a.description}" if a.description else ""
+                lines.append(f"    {a.name}({args_str}){danger}{prio}{desc}")
+
+        if self.shield:
+            lines.append("  Shield (safety limits):")
+            for s in self.shield:
+                unit = f" {s.unit}" if s.unit else ""
+                lines.append(f"    {s.name}: {s.type} = {s.value}{unit}")
+
+        return "\n".join(lines)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> NRPManifest:
+        """Parse a manifest from JSON/dict."""
+        nrp_id = NRPId.parse(data["nrp_id"])
+        return cls(
+            nrp_id=nrp_id,
+            manufacturer=data.get("manufacturer", ""),
+            model=data.get("model", ""),
+            firmware=data.get("firmware", ""),
+            observe=[ChannelSpec(**c) for c in data.get("observe", [])],
+            act=[ActionSpec(
+                name=a["name"],
+                args=a.get("args", {}),
+                description=a.get("description", ""),
+                dangerous=a.get("dangerous", False),
+                priority=a.get("priority", "normal"),
+                returns=a.get("returns", ""),
+            ) for a in data.get("act", [])],
+            shield=[ShieldSpec(**s) for s in data.get("shield", [])],
+            tags=data.get("tags", {}),
+        )
+
+    @classmethod
+    def from_json(cls, text: str) -> NRPManifest:
+        return cls.from_dict(json.loads(text))
+

{halyn-2.1.2 → halyn-2.2.0}/src/halyn/control_plane.py

@@ -20,7 +20,7 @@ import time
 from dataclasses import dataclass, field
 from typing import Any
 
-from nrp import NRPDriver, NRPId, NRPManifest, EventBus, Severity
+from halyn._nrp import NRPDriver, NRPId, NRPManifest, EventBus, Severity
 
 from .engine import Engine
 from .types import Action, Result, ActionStatus

{halyn-2.1.2 → halyn-2.2.0}/src/halyn/drivers/browser.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 import json
 import subprocess
 from typing import Any
-from nrp import NRPDriver, ShieldRule, ShieldType
+from halyn._nrp import NRPDriver, ShieldRule, ShieldType
 
 class BrowserDriver(NRPDriver):
     def __init__(self, cdp_url: str = "http://localhost:9222") -> None:

{halyn-2.1.2 → halyn-2.2.0}/src/halyn/drivers/dds.py

@@ -17,7 +17,7 @@ import logging
 import time
 from typing import Any
 
-from nrp import (
+from halyn._nrp import (
     NRPDriver, NRPManifest, NRPId,
     ChannelSpec, ActionSpec, ShieldSpec, ShieldRule, ShieldType,
 )

{halyn-2.1.2 → halyn-2.2.0}/src/halyn/drivers/docker.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 import json
 import subprocess
 from typing import Any
-from nrp import NRPDriver, ShieldRule, ShieldType
+from halyn._nrp import NRPDriver, ShieldRule, ShieldType
 
 class DockerDriver(NRPDriver):
     def __init__(self, host: str = "unix:///var/run/docker.sock") -> None:

{halyn-2.1.2 → halyn-2.2.0}/src/halyn/drivers/http_auto.py

@@ -18,7 +18,7 @@ import logging
 from typing import Any
 from urllib.parse import urljoin
 
-from nrp import NRPDriver, ShieldRule, ShieldType
+from halyn._nrp import NRPDriver, ShieldRule, ShieldType
 
 log = logging.getLogger("halyn.drivers.http_auto")
 
@@ -60,7 +60,7 @@ class HTTPAutoDriver(NRPDriver):
         self._endpoints: list[dict[str, Any]] = []
 
     def manifest(self):
-        from nrp import NRPManifest, ChannelSpec, ActionSpec, ShieldSpec
+        from halyn._nrp import NRPManifest, ChannelSpec, ActionSpec, ShieldSpec
         nrp_id = self._nrp_id
         observe_channels = [
             ChannelSpec("health", "string", description="API health status"),

{halyn-2.1.2 → halyn-2.2.0}/src/halyn/drivers/mqtt.py

@@ -16,7 +16,7 @@ import json
 import time
 from typing import Any
 
-from nrp import NRPDriver, ShieldRule, ShieldType
+from halyn._nrp import NRPDriver, ShieldRule, ShieldType
 
 
 class MQTTDriver(NRPDriver):

{halyn-2.1.2 → halyn-2.2.0}/src/halyn/drivers/opcua.py

@@ -10,7 +10,7 @@ The language of factories.
 """
 from __future__ import annotations
 from typing import Any
-from nrp import NRPDriver, ShieldRule, ShieldType
+from halyn._nrp import NRPDriver, ShieldRule, ShieldType
 
 class OPCUADriver(NRPDriver):
     def __init__(self, endpoint: str = "opc.tcp://localhost:4840",

{halyn-2.1.2 → halyn-2.2.0}/src/halyn/drivers/ros2.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 from typing import Any
 
-from nrp import NRPDriver, ShieldRule, ShieldType
+from halyn._nrp import NRPDriver, ShieldRule, ShieldType
 
 
 class ROS2Driver(NRPDriver):

{halyn-2.1.2 → halyn-2.2.0}/src/halyn/drivers/serial.py

@@ -15,7 +15,7 @@ import logging
 import struct
 from typing import Any
 
-from nrp import NRPDriver, NRPManifest, NRPId, ChannelSpec, ActionSpec, ShieldSpec, ShieldRule, ShieldType
+from halyn._nrp import NRPDriver, NRPManifest, NRPId, ChannelSpec, ActionSpec, ShieldSpec, ShieldRule, ShieldType
 
 log = logging.getLogger("halyn.drivers.serial")
 

{halyn-2.1.2 → halyn-2.2.0}/src/halyn/drivers/socket_raw.py

@@ -17,7 +17,7 @@ import socket
 import time
 from typing import Any
 
-from nrp import (
+from halyn._nrp import (
     NRPDriver, NRPManifest, NRPId,
     ChannelSpec, ActionSpec, ShieldSpec, ShieldRule, ShieldType,
 )

{halyn-2.1.2 → halyn-2.2.0}/src/halyn/drivers/ssh.py

@@ -12,9 +12,9 @@ import subprocess
 import shlex
 from typing import Any
 
-from nrp import NRPDriver, ShieldRule, ShieldType
-from nrp import NRPId
-from nrp import NRPManifest, ChannelSpec, ActionSpec, ShieldSpec
+from halyn._nrp import NRPDriver, ShieldRule, ShieldType
+from halyn._nrp import NRPId
+from halyn._nrp import NRPManifest, ChannelSpec, ActionSpec, ShieldSpec
 
 
 class SSHDriver(NRPDriver):

{halyn-2.1.2 → halyn-2.2.0}/src/halyn/drivers/unitree.py

@@ -10,7 +10,7 @@ Falls back to HTTP API if SDK not available.
 """
 from __future__ import annotations
 from typing import Any
-from nrp import NRPDriver, ShieldRule, ShieldType
+from halyn._nrp import NRPDriver, ShieldRule, ShieldType
 
 class UnitreeDriver(NRPDriver):
     def __init__(self, robot_ip: str = "192.168.123.161", model: str = "g1") -> None:

{halyn-2.1.2 → halyn-2.2.0}/src/halyn/drivers/websocket.py

@@ -17,7 +17,7 @@ import logging
 import time
 from typing import Any
 
-from nrp import (
+from halyn._nrp import (
     NRPDriver, NRPManifest, NRPId,
     ChannelSpec, ActionSpec, ShieldSpec, ShieldRule, ShieldType, Severity,
 )

{halyn-2.1.2 → halyn-2.2.0}/src/halyn/nrp_bridge.py

@@ -20,11 +20,11 @@ from __future__ import annotations
 import logging
 from typing import Any
 
-from nrp import NRPDriver, ShieldRule, ShieldType
+from halyn._nrp import NRPDriver, ShieldRule, ShieldType
 from .engine import Engine
-from nrp import NRPId
-from nrp import NRPManifest
-from nrp import EventBus, NRPEvent, Severity
+from halyn._nrp import NRPId
+from halyn._nrp import NRPManifest
+from halyn._nrp import EventBus, NRPEvent, Severity
 from .types import Node, NodeKind, ToolCategory, ActionStatus
 
 log = logging.getLogger("halyn.nrp")

{halyn-2.1.2 → halyn-2.2.0/src/halyn.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: halyn
-Version: 2.1.2
+Version: 2.2.0
 Summary: Halyn — The governance layer for AI agents. Every action intercepted. Every decision auditable.
 Author-email: Elmadani SALKA <contact@halyn.dev>
 License: BSL-1.1
@@ -20,7 +20,6 @@ Classifier: Topic :: Security
 Classifier: Topic :: System :: Systems Administration
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-License-File: LICENSE
 Requires-Dist: aiohttp>=3.9
 Provides-Extra: iot
 Requires-Dist: paho-mqtt; extra == "iot"
@@ -29,7 +28,6 @@ Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-asyncio; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
-Dynamic: license-file
 
 <div align="center">
 
@@ -80,19 +78,21 @@ Every action produces a cryptographic proof stored locally. Not in the cloud. No
 
 ## Install
 
+**Option 1 — pip** (Python 3.10+):
+
 ```bash
-pip install halyn
+pip install halyn==2.1.3
 halyn serve
 ```
 
-Opens the dashboard at `http://localhost:7420`. Nothing leaves your machine.
+**Option 2 — curl** (Linux / macOS):
 
 ```bash
-# Or with curl
 curl -fsSL https://halyn.dev/install | bash
 ```
 
-The install script tells you exactly what it will do before doing anything.
+Both options open the dashboard at `http://localhost:7420`. Nothing leaves your machine.
+The curl script verifies your Python version and asks permission before doing anything.
 
 ---
 
@@ -175,7 +175,7 @@ This means: if an AI agent makes an API call or accesses your system, Halyn sees
 | Provider | Models (March 2026) | API |
 |----------|---------------------|-----|
 | **Anthropic** | Claude Sonnet 4.6, Claude Opus 4.6, Claude Haiku 4.5 | api.anthropic.com |
-| **OpenAI** | GPT-4.1, GPT-4.1 mini, GPT-4.1 nano, o3, o4-mini | api.openai.com |
+| **OpenAI** | GPT| api.openai.com |
 | **Google** | Gemini 3.1 Pro, Gemini 3.1 Flash, Gemini 3.1 Flash-Lite | generativelanguage.googleapis.com |
 | **Mistral AI** | Mistral Large 2, Mistral Small 3, Codestral | api.mistral.ai |
 | **xAI** | Grok-3, Grok-3 mini | api.x.ai |

{halyn-2.1.2 → halyn-2.2.0}/src/halyn.egg-info/SOURCES.txt

@@ -1,4 +1,3 @@
-LICENSE
 README.md
 pyproject.toml
 src/halyn/__init__.py
@@ -30,6 +29,11 @@ src/halyn.egg-info/dependency_links.txt
 src/halyn.egg-info/entry_points.txt
 src/halyn.egg-info/requires.txt
 src/halyn.egg-info/top_level.txt
+src/halyn/_nrp/__init__.py
+src/halyn/_nrp/driver.py
+src/halyn/_nrp/events.py
+src/halyn/_nrp/identity.py
+src/halyn/_nrp/manifest.py
 src/halyn/drivers/__init__.py
 src/halyn/drivers/browser.py
 src/halyn/drivers/dds.py

{halyn-2.1.2 → halyn-2.2.0}/tests/test_halyn.py

@@ -1,4 +1,7 @@
-# Copyright (c) 2026 Elmadani SALKA. All rights reserved.
+# Copyright (c) 2026 Elmadani SALKA
+# Licensed under BSL-1.1. See LICENSE file.
+# Commercial use requires a license — contact@halyn.dev
+
 """
 Halyn Test Suite — Every README example must pass.
 

halyn-2.1.2/LICENSE

@@ -1,58 +0,0 @@
-Business Source License 1.1
-
-Licensor:             Elmadani SALKA
-Licensed Work:        Halyn
-                      The Licensed Work is (c) 2026 Elmadani SALKA
-Change Date:          2029-03-25
-Change License:       MIT License
-
-Additional Use Grant: You may use the Licensed Work for non-commercial purposes,
-                      research, education, and personal projects free of charge.
-                      Commercial use requires a separate commercial license.
-                      Contact: contact@halyn.dev
-
----
-
-The Business Source License (this document, or the "License") is not an Open
-Source license. However, the Licensed Work will eventually be made available
-under an Open Source License, as stated in this License.
-
-License text copyright (c) 2017 MariaDB Corporation Ab, All Rights Reserved.
-"Business Source License" is a trademark of MariaDB Corporation Ab.
-
-Parameters
-
-Licensor:             Elmadani SALKA
-Licensed Work:        Halyn — Enforceable safety for AI agents
-Change Date:          2029-03-25
-Change License:       MIT License
-
-For information about alternative licensing arrangements, contact:
-contact@halyn.dev · https://halyn.dev
-
----
-
-1. Grant of Rights
-
-The Licensor hereby grants you the right to copy, modify, create derivative
-works, redistribute, and make non-production use of the Licensed Work.
-
-The Licensor may make an Additional Use Grant, above, permitting limited
-production use.
-
-2. Change Date
-
-After the Change Date, the Grant of Rights is governed by the Change License.
-
-3. No Other Rights
-
-The License does not grant you any right in any trademark or logo of Licensor.
-
-4. Disclaimer of Warranty
-
-UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE EXTENT
-POSSIBLE, THE LICENSOR OFFERS THE LICENSED WORK AS-IS AND AS-AVAILABLE, AND
-MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE LICENSED WORK,
-WHETHER EXPRESS, IMPLIED, STATUTORY, OR OTHER.
-
-Full BSL 1.1 text: https://mariadb.com/bsl11/