agenticrail 0.1.0__py3-none-any.whl

agenticrail/__init__.py

@@ -0,0 +1,6 @@
+"""AgenticRail SDK — deterministic sequence enforcement for AI agents."""
+
+from agenticrail.client import RailClient, RailDecision, RailDenied, RailSequence
+
+__all__ = ["RailClient", "RailDecision", "RailDenied", "RailSequence"]
+__version__ = "0.1.0"

agenticrail/client.py

@@ -0,0 +1,184 @@
+"""AgenticRail gate client — core HTTP implementation."""
+
+from __future__ import annotations
+
+import time
+import uuid
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+import requests
+
+
+class RailDenied(Exception):
+    """Raised when the gate returns DENY or HALT."""
+
+    def __init__(self, decision: str, reasons: List[str], pack_id: str, step: str):
+        self.decision = decision
+        self.reasons = reasons
+        self.pack_id = pack_id
+        self.step = step
+        super().__init__(f"{decision} at '{step}': {reasons}")
+
+
+@dataclass
+class RailDecision:
+    decision: str           # ALLOW | DENY | HALT
+    pack_id: str
+    reasons: List[str]
+    executed: bool
+    sequence_id: str
+    step: str
+    receipt: dict = field(default_factory=dict)
+
+    @property
+    def allowed(self) -> bool:
+        return self.decision == "ALLOW"
+
+
+class RailSequence:
+    """
+    Stateful sequence helper. Tracks step_order and sends it only on the first
+    call — removes boilerplate from multi-step workflows.
+
+    Usage:
+        seq = client.sequence("my-seq-001", step_order=["step_a", "step_b", "step_c"])
+        seq.next("step_a")
+        seq.next("step_b")
+        seq.next("step_c")  # seals sequence
+    """
+
+    def __init__(self, client: "RailClient", sequence_id: str, step_order: List[str]):
+        self._client = client
+        self.sequence_id = sequence_id
+        self.step_order = step_order
+
+    def next(
+        self,
+        step: str,
+        *,
+        action_type: str = "CHECK_STATE",
+        action: Optional[str] = None,
+        inputs: Optional[dict] = None,
+        raise_on_deny: bool = True,
+    ) -> RailDecision:
+        # step_order must be sent on every call — the gate reads it from each
+        # payload to resolve the step index; it does not persist it server-side.
+        return self._client.evaluate(
+            self.sequence_id,
+            step,
+            action_type=action_type,
+            action=action,
+            inputs=inputs,
+            step_order=self.step_order,
+            raise_on_deny=raise_on_deny,
+        )
+
+
+class RailClient:
+    """
+    Thin client for the AgenticRail gate API.
+
+    Usage:
+        client = RailClient(api_key="DEMO-AGENTICRAIL-PUBLIC-2026")
+
+        # Direct calls — manage step_order yourself
+        client.evaluate("seq-001", "verify_identity", step_order=[...])
+        client.evaluate("seq-001", "assess_risk")
+
+        # Or use RailSequence helper
+        seq = client.sequence("seq-001", step_order=["verify_identity", "assess_risk"])
+        seq.next("verify_identity")
+        seq.next("assess_risk")
+    """
+
+    DEFAULT_BASE_URL = "https://api.agenticrail.nz/v1/evaluate"
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        model_id: str = "agent",
+        base_url: Optional[str] = None,
+        timeout: int = 10,
+    ):
+        self.api_key = api_key
+        self.model_id = model_id
+        self.base_url = (base_url or self.DEFAULT_BASE_URL).rstrip("/")
+        self.timeout = timeout
+
+    def evaluate(
+        self,
+        sequence_id: str,
+        step: str,
+        *,
+        action_type: str = "CHECK_STATE",
+        action: Optional[str] = None,
+        inputs: Optional[dict] = None,
+        step_order: Optional[List[str]] = None,
+        raise_on_deny: bool = True,
+    ) -> RailDecision:
+        """
+        Evaluate one step of a sequence against the AgenticRail gate.
+
+        Args:
+            sequence_id: Unique identifier for this agent run.
+            step: Step name (must equal function; must match step_order).
+            action_type: One of CHECK_STATE, VALIDATE_INPUT, RECORD_RESULT, etc.
+            action: Human-readable action label (defaults to step name).
+            inputs: Arbitrary metadata attached to this step.
+            step_order: Full ordered list of step names — send only on the first step.
+            raise_on_deny: If True (default), raise RailDenied on DENY or HALT.
+
+        Returns:
+            RailDecision with decision, pack_id, receipt, and reasons.
+
+        Raises:
+            RailDenied: If decision is DENY or HALT and raise_on_deny is True.
+            requests.HTTPError: On non-2xx HTTP responses.
+        """
+        payload: dict = {
+            "schema_version": "1.0",
+            "model_id": self.model_id,
+            "sequence_id": sequence_id,
+            "step": step,
+            "function": step,
+            "action_type": action_type,
+            "action": action if action is not None else step,
+            "inputs": inputs or {},
+            "nonce": str(uuid.uuid4()),
+            "ts_ms": int(time.time() * 1000),
+        }
+        if step_order is not None:
+            payload["step_order"] = step_order
+
+        resp = requests.post(
+            self.base_url,
+            json=payload,
+            headers={
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json",
+            },
+            timeout=self.timeout,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+
+        decision = RailDecision(
+            decision=data["decision"],
+            pack_id=data.get("pack_id", ""),
+            reasons=data.get("reasons", []),
+            executed=data.get("executed", False),
+            sequence_id=data.get("sequence_id", sequence_id),
+            step=data.get("step", step),
+            receipt=data.get("receipt", {}),
+        )
+
+        if raise_on_deny and not decision.allowed:
+            raise RailDenied(decision.decision, decision.reasons, decision.pack_id, step)
+
+        return decision
+
+    def sequence(self, sequence_id: str, step_order: List[str]) -> RailSequence:
+        """Create a stateful sequence helper that manages step_order automatically."""
+        return RailSequence(self, sequence_id, step_order)

agenticrail/integrations/__init__.py

@@ -0,0 +1,3 @@
+# Framework integrations are imported explicitly:
+#   from agenticrail.integrations.langgraph import LangGraphRail
+#   from agenticrail.integrations.crewai import CrewRailGuard

agenticrail/integrations/crewai.py

@@ -0,0 +1,141 @@
+"""CrewAI integration for AgenticRail."""
+
+from __future__ import annotations
+
+import uuid
+from typing import Any, List, Optional
+
+from agenticrail.client import RailClient, RailDenied
+
+
+class CrewRailGuard:
+    """
+    Guards a CrewAI Crew by calling the AgenticRail gate before each task executes.
+
+    Usage:
+        from agenticrail import RailClient
+        from agenticrail.integrations.crewai import CrewRailGuard
+
+        client = RailClient(api_key="YOUR_KEY")
+        guard = CrewRailGuard(
+            client,
+            step_order=["research_task", "analysis_task", "write_task"],
+        )
+
+        crew = Crew(
+            agents=[researcher, analyst, writer],
+            tasks=[research_task, analysis_task, write_task],
+        )
+
+        # Call guard.kickoff() instead of crew.kickoff()
+        result = guard.kickoff(crew, inputs={"topic": "EU AI Act enforcement"})
+
+    How it works:
+        1. guard.kickoff() gates step[0] before crew starts. Raises RailDenied on DENY.
+        2. A task_callback is injected into the crew. After each task completes, the
+           callback gates the NEXT step before CrewAI moves to it. If the gate denies,
+           a flag is set and a RailDenied is raised after kickoff returns.
+        3. The sequence is sealed when all tasks complete (the step_order's last step
+           is evaluated at the start of the last task).
+
+    Note on timing:
+        CrewAI's task_callback fires synchronously between tasks. However, if CrewAI
+        swallows the exception from task_callback, the denied task may still execute.
+        In that case, guard.kickoff() raises RailDenied after crew.kickoff() returns,
+        preserving the gate decision in the audit trail even if execution wasn't blocked.
+
+        For hard blocking, wrap task execution directly via guard.gate() before each
+        task in a custom orchestration loop (see examples/crewai_example.py).
+
+    New sequence per run:
+        Each call to guard.kickoff() generates a fresh sequence_id unless you pass
+        sequence_id= explicitly. This ensures each crew run is independently tracked.
+    """
+
+    def __init__(
+        self,
+        client: RailClient,
+        step_order: List[str],
+        *,
+        sequence_id: Optional[str] = None,
+        action_type: str = "CHECK_STATE",
+    ):
+        self._client = client
+        self.step_order = step_order
+        self._action_type = action_type
+        self._fixed_sequence_id = sequence_id
+        # Runtime state (reset on each kickoff)
+        self._sequence_id: str = ""
+        self._step_idx: int = 0
+        self._denied: Optional[RailDenied] = None
+
+    def _gate(self, step_name: str) -> None:
+        # step_order sent on every call — gate reads it from each payload
+        self._client.evaluate(
+            self._sequence_id,
+            step_name,
+            action_type=self._action_type,
+            action=f"execute {step_name}",
+            step_order=self.step_order,
+            raise_on_deny=True,
+        )
+
+    def gate(self, step_name: str) -> None:
+        """
+        Explicitly gate a single step. Use this for custom orchestration loops
+        where you control task execution directly.
+        """
+        if not self._sequence_id:
+            self._sequence_id = self._fixed_sequence_id or str(uuid.uuid4())
+        self._gate(step_name)
+        self._step_idx += 1
+
+    def reset(self, sequence_id: Optional[str] = None) -> None:
+        """Reset guard state for a new crew run."""
+        self._sequence_id = sequence_id or self._fixed_sequence_id or str(uuid.uuid4())
+        self._step_idx = 0
+        self._denied = None
+
+    def kickoff(self, crew: Any, **kwargs: Any) -> Any:
+        """
+        Gate-enabled replacement for crew.kickoff().
+
+        Gates step[0] before the crew starts. Injects a task_callback that gates
+        each subsequent step between tasks. Raises RailDenied if any step is denied.
+        """
+        self.reset()
+
+        # Gate the first step — raises immediately on DENY/HALT
+        first_step = self.step_order[self._step_idx]
+        self._gate(first_step)
+        self._step_idx += 1
+
+        # Capture any existing callback so we can chain it
+        existing_callback = getattr(crew, "task_callback", None)
+
+        def _task_callback(task_output: Any) -> None:
+            if self._denied:
+                return
+
+            # Gate the next step (if any remain)
+            if self._step_idx < len(self.step_order):
+                next_step = self.step_order[self._step_idx]
+                self._step_idx += 1
+                try:
+                    self._gate(next_step)
+                except RailDenied as e:
+                    self._denied = e
+                    # Cannot reliably stop CrewAI from inside a callback,
+                    # but we record the denial and raise after kickoff.
+
+            if existing_callback is not None:
+                existing_callback(task_output)
+
+        crew.task_callback = _task_callback
+
+        result = crew.kickoff(**kwargs)
+
+        if self._denied:
+            raise self._denied
+
+        return result

agenticrail/integrations/langgraph.py

@@ -0,0 +1,115 @@
+"""LangGraph integration for AgenticRail."""
+
+from __future__ import annotations
+
+import inspect
+import uuid
+from functools import wraps
+from typing import Any, Callable, Dict, List, Optional
+
+from agenticrail.client import RailClient
+
+
+class LangGraphRail:
+    """
+    Guards a LangGraph StateGraph by calling the AgenticRail gate before each
+    node executes. Each graph invocation gets its own sequence_id derived from
+    LangGraph's thread_id, so concurrent runs are isolated.
+
+    Usage:
+        from agenticrail import RailClient
+        from agenticrail.integrations.langgraph import LangGraphRail
+
+        client = RailClient(api_key="YOUR_KEY")
+        rail = LangGraphRail(client, step_order=["research", "analyze", "write"])
+
+        # Wrap your nodes at add_node time
+        builder.add_node("research", rail.wrap("research", research_fn))
+        builder.add_node("analyze",  rail.wrap("analyze",  analyze_fn))
+        builder.add_node("write",    rail.wrap("write",    write_fn))
+
+        graph = builder.compile()
+
+        # thread_id becomes the sequence_id — each run is isolated
+        result = graph.invoke(
+            {"messages": [...]},
+            config={"configurable": {"thread_id": "run-abc-001"}},
+        )
+
+    Gate enforcement:
+        - ALLOW  → node function executes normally.
+        - DENY   → RailDenied raised; LangGraph halts the graph.
+        - HALT   → RailDenied raised; LangGraph halts the graph.
+
+    Sequence isolation:
+        Each unique thread_id gets its own AgenticRail sequence. If you invoke
+        the same graph twice with different thread_ids, both are tracked
+        independently. If thread_id is not provided in config, a random UUID is
+        used (not recommended — you lose the audit trail correlation).
+    """
+
+    def __init__(
+        self,
+        client: RailClient,
+        step_order: List[str],
+        *,
+        fallback_sequence_id: Optional[str] = None,
+    ):
+        self._client = client
+        self.step_order = step_order
+        self._fallback_sequence_id = fallback_sequence_id or str(uuid.uuid4())
+
+    def _resolve_sequence_id(self, config: Any) -> str:
+        if config and isinstance(config, dict):
+            configurable = config.get("configurable") or {}
+            thread_id = (
+                configurable.get("thread_id")
+                or configurable.get("sequence_id")
+            )
+            if thread_id:
+                return str(thread_id)
+        return self._fallback_sequence_id
+
+    def wrap(
+        self,
+        step_name: str,
+        fn: Callable,
+        *,
+        action_type: str = "CHECK_STATE",
+    ) -> Callable:
+        """
+        Wrap a LangGraph node function with AgenticRail pre-execution gate enforcement.
+
+        Args:
+            step_name: Must match the corresponding entry in step_order.
+            fn: The original node function (state -> dict, or state, config -> dict).
+            action_type: Gate action type (default CHECK_STATE).
+
+        Returns:
+            Wrapped node function with identical signature.
+        """
+        # Check if the original function accepts a config argument
+        try:
+            sig = inspect.signature(fn)
+            _fn_takes_config = len(sig.parameters) > 1
+        except (ValueError, TypeError):
+            _fn_takes_config = False
+
+        @wraps(fn)
+        def guarded(state: Any, config: Any = None) -> Any:
+            seq_id = self._resolve_sequence_id(config)
+            # step_order sent on every call — gate reads it from each payload
+            self._client.evaluate(
+                seq_id,
+                step_name,
+                action_type=action_type,
+                action=f"execute {step_name}",
+                step_order=self.step_order,
+                raise_on_deny=True,
+            )
+
+            if _fn_takes_config and config is not None:
+                return fn(state, config)
+            return fn(state)
+
+        return guarded

agenticrail-0.1.0.dist-info/METADATA

@@ -0,0 +1,304 @@
+Metadata-Version: 2.4
+Name: agenticrail
+Version: 0.1.0
+Summary: AgenticRail SDK — deterministic sequence enforcement for AI agents
+Project-URL: Homepage, https://agenticrail.nz
+Project-URL: Documentation, https://agenticrail.nz/docs
+Project-URL: Repository, https://github.com/MSMD-RUA/agenticrail-sdk
+Project-URL: Bug Tracker, https://github.com/MSMD-RUA/agenticrail-sdk/issues
+License: MIT
+Keywords: ai-agents,compliance,crewai,enforcement,langgraph,sequence
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Requires-Dist: requests>=2.28
+Provides-Extra: all
+Requires-Dist: crewai>=0.60; extra == 'all'
+Requires-Dist: langchain-core>=0.1; extra == 'all'
+Requires-Dist: langgraph>=0.1; extra == 'all'
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.60; extra == 'crewai'
+Provides-Extra: dev
+Requires-Dist: pytest-mock; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Requires-Dist: responses; extra == 'dev'
+Provides-Extra: langgraph
+Requires-Dist: langchain-core>=0.1; extra == 'langgraph'
+Requires-Dist: langgraph>=0.1; extra == 'langgraph'
+Description-Content-Type: text/markdown
+
+# agenticrail
+
+AgenticRail Python SDK — deterministic sequence enforcement for AI agents.
+
+Gate every step of your agent workflow before it executes. Cryptographic receipts. Zero enforcement failures.
+
+```
+pip install agenticrail
+```
+
+---
+
+## What it does
+
+AgenticRail sits beneath your agent and enforces that steps run in the right order, with no skips, no replays, and no re-entry after a sequence is sealed. Every decision — ALLOW, DENY, or HALT — produces a cryptographically signed receipt stored at the edge.
+
+Three verdicts:
+- **ALLOW** — step is clear, your agent code executes
+- **DENY** — enforcement violation (wrong order, replay, sealed), execution blocked
+- **HALT** — hard stop (injection attempt, poison payload detected), execution blocked
+
+---
+
+## Install
+
+```bash
+# Core client only
+pip install agenticrail
+
+# With LangGraph support
+pip install "agenticrail[langgraph]"
+
+# With CrewAI support
+pip install "agenticrail[crewai]"
+
+# Everything
+pip install "agenticrail[all]"
+```
+
+---
+
+## Quick start — any framework
+
+```python
+from agenticrail import RailClient
+
+client = RailClient(api_key="DEMO-AGENTICRAIL-PUBLIC-2026")
+
+# RailSequence sends step_order on every call — the gate reads it from each payload
+seq = client.sequence(
+    sequence_id="my-agent-run-001",
+    step_order=["verify_identity", "assess_risk", "execute_transfer", "audit_ledger"],
+)
+
+seq.next("verify_identity")    # → ALLOW
+seq.next("assess_risk")        # → ALLOW
+seq.next("execute_transfer")   # → ALLOW
+seq.next("audit_ledger")       # → ALLOW (seals sequence)
+
+# Any out-of-order, replay, or post-seal call raises RailDenied
+seq.next("verify_identity")    # → raises RailDenied: SEALED_SEQUENCE
+```
+
+Get a production API key at [agenticrail.nz](https://agenticrail.nz).
+
+---
+
+## LangGraph integration
+
+Wrap each node at `add_node` time. Uses `thread_id` from LangGraph config as the sequence_id — each graph invocation is isolated.
+
+```python
+from langgraph.graph import StateGraph, END
+from agenticrail import RailClient
+from agenticrail.integrations.langgraph import LangGraphRail
+
+client = RailClient(api_key="YOUR_KEY")
+rail = LangGraphRail(
+    client,
+    step_order=["research", "analyze", "write_report", "review"],
+)
+
+builder = StateGraph(AgentState)
+
+# Wrap each node — gate fires before node execution
+builder.add_node("research",     rail.wrap("research",     research_fn))
+builder.add_node("analyze",      rail.wrap("analyze",      analyze_fn))
+builder.add_node("write_report", rail.wrap("write_report", write_report_fn))
+builder.add_node("review",       rail.wrap("review",       review_fn))
+
+builder.set_entry_point("research")
+builder.add_edge("research",     "analyze")
+builder.add_edge("analyze",      "write_report")
+builder.add_edge("write_report", "review")
+builder.add_edge("review",       END)
+
+graph = builder.compile()
+
+# thread_id → sequence_id: each invocation is independently tracked and verifiable
+result = graph.invoke(
+    {"query": "EU AI Act compliance checklist"},
+    config={"configurable": {"thread_id": "run-2026-001"}},
+)
+```
+
+**What happens on DENY or HALT:**
+`rail.wrap()` raises `RailDenied` inside the node. LangGraph catches unhandled node exceptions and halts graph execution. No subsequent nodes run.
+
+**Concurrent runs:**
+Each `thread_id` is a separate sequence. Concurrent graph invocations with different thread IDs do not interfere — the gate tracks them independently via Durable Objects.
+
+---
+
+## CrewAI integration
+
+Use `guard.kickoff()` instead of `crew.kickoff()`. Step[0] is gated before the crew starts; subsequent steps are gated via a task callback injected between tasks.
+
+```python
+from crewai import Crew
+from agenticrail import RailClient
+from agenticrail.integrations.crewai import CrewRailGuard
+
+client = RailClient(api_key="YOUR_KEY")
+guard = CrewRailGuard(
+    client,
+    step_order=["research_task", "analysis_task", "write_task"],
+)
+
+crew = Crew(
+    agents=[researcher, analyst, writer],
+    tasks=[research_task, analysis_task, write_task],
+)
+
+# Drop-in replacement for crew.kickoff()
+# Each call generates a fresh sequence_id — each run is independently tracked
+result = guard.kickoff(crew, inputs={"topic": "AI governance"})
+```
+
+**Note on blocking:** CrewAI's `task_callback` fires synchronously between tasks, so the gate can block task N before task N starts. However, if CrewAI swallows exceptions in callbacks, a denied task may still execute. In that case, `guard.kickoff()` raises `RailDenied` after the crew finishes, preserving the denial in the audit trail.
+
+For hard blocking (guaranteed pre-execution), use `guard.gate()` in a custom orchestration loop:
+
+```python
+guard.reset()
+for step, task_fn in zip(STEP_ORDER, task_functions):
+    guard.gate(step)   # raises RailDenied immediately on DENY
+    task_fn()
+```
+
+---
+
+## API reference
+
+### `RailClient`
+
+```python
+client = RailClient(
+    api_key="...",       # Required. Bearer token for the wrapper API.
+    model_id="agent",    # Optional. Identifies your agent in receipts.
+    base_url=None,       # Optional. Defaults to api.agenticrail.nz/v1/evaluate.
+    timeout=10,          # Optional. Request timeout in seconds.
+)
+```
+
+#### `client.evaluate(sequence_id, step, *, ...)`
+
+```python
+decision = client.evaluate(
+    sequence_id="my-run-001",
+    step="verify_identity",
+    action_type="CHECK_STATE",     # Optional. Default: CHECK_STATE.
+    action="verify user identity", # Optional. Human-readable label.
+    inputs={"user_id": "u123"},    # Optional. Metadata attached to receipt.
+    step_order=[...],              # Required on every call — gate reads it from each payload.
+    raise_on_deny=True,            # Optional. Default True.
+)
+# decision.decision  → "ALLOW" | "DENY" | "HALT"
+# decision.allowed   → True if ALLOW
+# decision.pack_id   → SHA-256 receipt hash
+# decision.receipt   → full signed receipt dict
+# decision.reasons   → list of reason codes on DENY/HALT
+```
+
+#### `client.sequence(sequence_id, step_order)`
+
+Returns a `RailSequence` that tracks `step_order` state — call `.next(step)` for each step without managing `step_order` yourself.
+
+### `RailDenied`
+
+```python
+try:
+    seq.next("execute_transfer")
+except RailDenied as e:
+    print(e.decision)   # "DENY" or "HALT"
+    print(e.reasons)    # ["SEQUENCE_VIOLATION"]
+    print(e.pack_id)    # receipt hash for audit
+    print(e.step)       # "execute_transfer"
+```
+
+### `LangGraphRail`
+
+```python
+rail = LangGraphRail(
+    client,
+    step_order=["step_a", "step_b", "step_c"],
+    fallback_sequence_id=None,  # Used when thread_id not in config
+)
+wrapped_fn = rail.wrap("step_a", original_fn, action_type="CHECK_STATE")
+```
+
+### `CrewRailGuard`
+
+```python
+guard = CrewRailGuard(
+    client,
+    step_order=["task_1", "task_2", "task_3"],
+    sequence_id=None,    # Optional. Auto-generated per kickoff() call if None.
+    action_type="CHECK_STATE",
+)
+result = guard.kickoff(crew, inputs={...})
+guard.gate("task_1")     # Explicit gate for custom loops
+guard.reset()            # Reset state for a new run
+```
+
+---
+
+## Compliance reports
+
+Every `pack_id` in a `RailDecision` is a verifiable receipt. Paste your sequence ID into the report generator or call it programmatically:
+
+```bash
+curl -X POST https://api.agenticrail.nz/v1/report \
+  -H "Authorization: Bearer YOUR_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{"sequence_id": "my-run-001", "format": "json"}'
+```
+
+Returns: chain proof, HMAC verification, enforcement log, AI-written compliance narrative (EU AI Act Article 11).
+
+Demo sequences (using `DEMO-AGENTICRAIL-PUBLIC-2026`) are verifiable at [report.agenticrail.nz](https://report.agenticrail.nz) — no auth needed.
+
+---
+
+## Action types
+
+| Type | Use when |
+|------|----------|
+| `CHECK_STATE` | Reading or observing state (default) |
+| `VALIDATE_INPUT` | Verifying inputs before acting |
+| `RECORD_RESULT` | Writing or committing an outcome |
+| `CLARIFY_NEXT_STEP` | Asking for clarification |
+| `SELECT_NEXT_STEP` | Choosing a path |
+| `WAIT_FOR_SIGNAL` | Pausing for an external trigger |
+| `PAUSE_CYCLE` | Deliberate suspension |
+| `REDUCE_STIMULUS` | Backing off |
+
+---
+
+## Links
+
+- **API docs:** [agenticrail.nz/docs](https://agenticrail.nz/docs)
+- **Interactive demo:** [agenticrail.nz/demo](https://agenticrail.nz/demo)
+- **Compliance matrix (60+ frameworks):** [agenticrail.nz/compliance](https://agenticrail.nz/compliance)
+- **Verify a sequence:** [report.agenticrail.nz](https://report.agenticrail.nz)
+
+---
+
+*TUARA KURI LIMITED — trading as AgenticRail. Hokianga, New Zealand.*

agenticrail-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+agenticrail/__init__.py,sha256=LxWNeoEQj5e1bWAG52099Dj2G12q0uAmg3epsRkNvv0,253
+agenticrail/client.py,sha256=ADtKEUuMBtJqRSP9qhtMDCYMHjKNWG4dKChChFV8E2s,5854
+agenticrail/integrations/__init__.py,sha256=kDk9Dna5jzlt8-MY_djjEmb3cfOPvmQiqbAnFijHfrk,177
+agenticrail/integrations/crewai.py,sha256=tOyFEUkpMkK26N_0jGGHwFQ2qCubuRI4evQxaUGC3WY,5114
+agenticrail/integrations/langgraph.py,sha256=bakC2At2vo2B3NYdBEi7O8DcYBNxqdvZ50YE-fxuxSQ,3970
+agenticrail-0.1.0.dist-info/METADATA,sha256=FHb-bYNOf7sNrTuYWSIgYHXx_J6ntPUlMg6NldQiQxU,10100
+agenticrail-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+agenticrail-0.1.0.dist-info/RECORD,,

agenticrail-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any