halyn 2.1.3__tar.gz → 2.2.1__tar.gz

{halyn-2.1.3/src/halyn.egg-info → halyn-2.2.1}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: halyn
-Version: 2.1.3
+Version: 2.2.1
 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
+License-Expression: BUSL-1.1
 Project-URL: Homepage, https://halyn.dev
 Project-URL: Repository, https://github.com/halyndev/halyn
 Project-URL: Issues, https://github.com/halyndev/halyn/issues
@@ -39,7 +39,7 @@ Dynamic: license-file
 
 [![PyPI](https://img.shields.io/pypi/v/halyn?style=flat-square&color=20c754)](https://pypi.org/project/halyn/)
 [![Python 3.10+](https://img.shields.io/badge/Python-3.10+-20c754?style=flat-square)](https://python.org)
-[![License: BSL-1.1](https://img.shields.io/badge/License-BSL--1.1-orange?style=flat-square)](LICENSE)
+[![License: BSL-1.1](https://img.shields.io/badge/License-BUSL--1.1-orange?style=flat-square)](LICENSE)
 [![Website](https://img.shields.io/badge/Website-halyn.dev-20c754?style=flat-square)](https://halyn.dev)
 
 Every action intercepted. Every decision auditable. The AI cannot bypass it.
@@ -80,19 +80,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 +177,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 |
@@ -287,7 +289,7 @@ See [CONTRIBUTING.md](CONTRIBUTING.md).
 
 ## License
 
-**[BSL-1.1](LICENSE)** — Business Source License 1.1
+**[BUSL-1.1](LICENSE)** — Business Source License 1.1
 
 - **Free** for personal use, research, and education
 - **Commercial use** requires a license — [contact@halyn.dev](mailto:contact@halyn.dev)

{halyn-2.1.3 → halyn-2.2.1}/README.md

@@ -6,7 +6,7 @@
 
 [![PyPI](https://img.shields.io/pypi/v/halyn?style=flat-square&color=20c754)](https://pypi.org/project/halyn/)
 [![Python 3.10+](https://img.shields.io/badge/Python-3.10+-20c754?style=flat-square)](https://python.org)
-[![License: BSL-1.1](https://img.shields.io/badge/License-BSL--1.1-orange?style=flat-square)](LICENSE)
+[![License: BSL-1.1](https://img.shields.io/badge/License-BUSL--1.1-orange?style=flat-square)](LICENSE)
 [![Website](https://img.shields.io/badge/Website-halyn.dev-20c754?style=flat-square)](https://halyn.dev)
 
 Every action intercepted. Every decision auditable. The AI cannot bypass it.
@@ -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 |
@@ -254,7 +256,7 @@ See [CONTRIBUTING.md](CONTRIBUTING.md).
 
 ## License
 
-**[BSL-1.1](LICENSE)** — Business Source License 1.1
+**[BUSL-1.1](LICENSE)** — Business Source License 1.1
 
 - **Free** for personal use, research, and education
 - **Commercial use** requires a license — [contact@halyn.dev](mailto:contact@halyn.dev)

{halyn-2.1.3 → halyn-2.2.1}/pyproject.toml

@@ -1,9 +1,10 @@
 [project]
 name = "halyn"
-version = "2.1.3"
+version = "2.2.1"
 description = "Halyn — The governance layer for AI agents. Every action intercepted. Every decision auditable."
 requires-python = ">=3.10"
-license = {text = "BSL-1.1"}
+license = "BUSL-1.1"
+license-files = ["LICENSE"]
 authors = [{name = "Elmadani SALKA", email = "contact@halyn.dev"}]
 readme = "README.md"
 keywords = [
@@ -45,7 +46,7 @@ where = ["src"]
 halyn = ["py.typed"]
 
 [build-system]
-requires = ["setuptools>=68", "wheel"]
+requires = ["setuptools>=77", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [tool.ruff]

{halyn-2.1.3 → halyn-2.2.1}/src/halyn/__init__.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Elmadani SALKA
-# Licensed under BSL-1.1. See LICENSE file.
+# Licensed under BUSL-1.1. See LICENSE file.
 # Commercial use requires a license — contact@halyn.dev
 
 """
@@ -9,9 +9,9 @@ Every action intercepted. Every decision auditable.
 The AI cannot bypass it.
 """
 
-__version__ = "2.1.3"
+__version__ = "2.2.1"
 __author__ = "Elmadani SALKA"
-__license__ = "BSL-1.1"
+__license__ = "BUSL-1.1"
 __email__ = "contact@halyn.dev"
 __url__ = "https://halyn.dev"
 

{halyn-2.1.3 → halyn-2.2.1}/src/halyn/__main__.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2026 Elmadani SALKA
-# Licensed under BSL-1.1. See LICENSE file.
+# Licensed under BUSL-1.1. See LICENSE file.
 # Commercial use requires a license — contact@halyn.dev
 
 from .cli import main

halyn-2.2.1/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.1/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.1/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.1/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})"
+