bounded-agent 0.1.0__py3-none-any.whl

bounded_agent/__init__.py

@@ -0,0 +1,22 @@
+"""bounded-agent — contract-bounded autonomy for LLM agents.
+
+Five primitives that make an agent safe to leave alone. Deterministic spine, agentic
+leaves: code you can test decides the flow; the LLM reasons inside well-fenced steps and
+never pilots the loop. See README.md for the full argument; each module's docstring is a
+chapter.
+"""
+from __future__ import annotations
+
+from bounded_agent.actions import ActionRecord, ActionSet, ExecOutcome
+from bounded_agent.contracts import Contract, ContractBook, Gate
+from bounded_agent.envelope import Envelope
+from bounded_agent.leaf import LeafError, TypedLeaf, escalate_only
+from bounded_agent.ledgers import EvidenceLedger, IdempotencyLedger
+
+__all__ = [
+    "Contract", "ContractBook", "Gate",
+    "TypedLeaf", "LeafError", "escalate_only",
+    "ActionSet", "ActionRecord", "ExecOutcome",
+    "EvidenceLedger", "IdempotencyLedger",
+    "Envelope",
+]

bounded_agent/actions.py

@@ -0,0 +1,110 @@
+"""Chapter 3 — The double-closed action set: agent actions safe by construction.
+
+An autonomous agent's actions must clear TWO independent closed sets before running:
+
+1. **Contracted** — the action name appears in a contract's ``allows`` list that a ``Gate``
+   granted (chapter 1). A human put that name in the book.
+2. **Registered** — the action name has an implementation registered here. An engineer wrote
+   and reviewed that handler.
+
+The intersection is the executable surface; everything else — a typo'd contract, a
+hallucinated action name, a prompt-injected "please also run …" — is **refused and
+recorded**, not an error path someone forgot. Capability creep now requires changing two
+artifacts, in two reviews.
+
+Execution runs inside the envelope (chapter 5) and journals to the evidence ledger
+(chapter 4). Two details that earn their keep:
+
+- **A raising handler is a recorded failure, not an escape.** After an action *starts*,
+  every outcome — success, failure, crash — must become a record that is ledgered and
+  notified. An exception unwinding through an unattended loop is an agent that stops
+  watching mid-run and tells nobody.
+- **Failed attempts spend breaker budget.** The breaker bounds *attempts*, not successes —
+  a handler that crashes N times in a loop is exactly the runaway the breaker exists for.
+"""
+from __future__ import annotations
+
+from typing import Callable, Literal, Sequence
+
+from pydantic import BaseModel, ConfigDict
+
+from bounded_agent.envelope import Envelope
+from bounded_agent.ledgers import EvidenceLedger, Period
+
+#: A handler does the work and reports (ok, detail). What "the work" is — a subprocess, an
+#: API call, a container restart — is its business; the set only knows names and outcomes.
+Handler = Callable[[], tuple[bool, str]]
+
+#: (contract_name, the action names that contract allows) — straight from ContractBook.granted.
+Target = tuple[str, Sequence[str]]
+
+Status = Literal["executed-ok", "executed-failed", "refused", "halted"]
+
+
+class ActionRecord(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    contract: str
+    action: str
+    status: Status
+    detail: str = ""
+
+
+class ExecOutcome(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    blocked_reason: str | None          # disarmed | kill-switch | None (ran)
+    records: tuple[ActionRecord, ...] = ()
+    executed: int = 0                   # attempts, successful or not
+
+
+class ActionSet:
+    """The registered half of the double-closed check, plus the execution loop."""
+
+    def __init__(self) -> None:
+        self._handlers: dict[str, Handler] = {}
+
+    def register(self, name: str, handler: Handler) -> None:
+        self._handlers[name] = handler
+
+    def execute(self, targets: Sequence[Target], envelope: Envelope, *,
+                ledger: EvidenceLedger | None = None,
+                period: Period | None = None) -> ExecOutcome:
+        def emit(rec: ActionRecord) -> None:
+            if ledger is not None and period is not None:
+                ledger.append(rec, period=period)
+            envelope.notify(f"{rec.status}: {rec.action} on {rec.contract}"
+                            + (f" ({rec.detail})" if rec.detail else ""))
+
+        blocked = envelope.blocked_reason()
+        if blocked is not None:
+            rec = ActionRecord(contract="*", action="*", status="halted", detail=blocked)
+            emit(rec)
+            return ExecOutcome(blocked_reason=blocked, records=(rec,))
+
+        records: list[ActionRecord] = []
+        executed = 0
+        for contract, actions in targets:
+            for action in actions:
+                if envelope.breaker_tripped(executed):
+                    rec = ActionRecord(contract=contract, action=action, status="halted",
+                                       detail=f"breaker: {envelope.max_actions_per_run}/run")
+                    records.append(rec); emit(rec)
+                    return ExecOutcome(blocked_reason=None, records=tuple(records),
+                                       executed=executed)
+                handler = self._handlers.get(action)
+                if handler is None:              # contracted but not implemented → refused
+                    rec = ActionRecord(contract=contract, action=action, status="refused",
+                                       detail="not registered (closed set)")
+                    records.append(rec); emit(rec)
+                    continue
+                try:
+                    ok, detail = handler()
+                    status: Status = "executed-ok" if ok else "executed-failed"
+                except Exception as e:  # noqa: BLE001 — a crash is a RECORD, never an escape
+                    detail, status = f"{type(e).__name__}: {e}", "executed-failed"
+                rec = ActionRecord(contract=contract, action=action, status=status,
+                                   detail=detail)
+                records.append(rec); emit(rec)
+                executed += 1                    # attempts spend breaker budget
+        return ExecOutcome(blocked_reason=None, records=tuple(records), executed=executed)

bounded_agent/contracts.py

@@ -0,0 +1,86 @@
+"""Chapter 1 — Contracts & gates: deciding who may do what, before any agent runs.
+
+The pattern: autonomy is granted by a **declared book of contracts**, never by code that
+happens to be reachable. A human edits the book (and signs off on new entries); the machine
+operates strictly inside it. Each contract names:
+
+- a ``scope`` — the blast-radius label ("checkout-stack", "reporting-db") the grant is
+  confined to;
+- a ``tier`` — how much autonomy: ``observe`` (read and report), ``propose`` (draft a fix a
+  human executes), ``act`` (execute its own ``allows`` list). Tiers are ORDERED: an ``act``
+  contract clears a ``propose`` gate, never the reverse;
+- an ``allows`` list — the CLOSED set of action names the contract permits (see
+  ``actions.py`` for the second half of the double-closed check).
+
+Two hard rules encoded here:
+
+1. **Absence is never authorization.** A missing or malformed book RAISES; an entry that is
+   not active, out of scope, or under-tiered grants nothing. There is no default-allow path.
+2. **The lifecycle vocabulary belongs to the caller.** Your workflow might call live entries
+   "active", "LIVE", or "ratified" — the gate's ``active_status`` is configurable rather than
+   baked into a type, because a library that hardcodes your status words will be wrong in
+   somebody's workflow.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Literal
+
+import yaml
+from pydantic import BaseModel, ConfigDict
+
+Tier = Literal["observe", "propose", "act"]
+
+#: The ordering that makes tiers meaningful: a gate requiring tier T grants any contract
+#: whose tier ranks >= T.
+_TIER_RANK: dict[str, int] = {"observe": 0, "propose": 1, "act": 2}
+
+
+class Contract(BaseModel):
+    """One declared grant. Extra YAML fields (owners, SLAs, notes) are ignored — the book
+    can carry your operational metadata without this library needing to model it."""
+    model_config = ConfigDict(frozen=True, extra="ignore")
+
+    name: str
+    status: str = "active"
+    scope: str
+    tier: Tier = "observe"
+    allows: tuple[str, ...] = ()
+
+
+class Gate(BaseModel):
+    """A composable authorization predicate — the question "may this contract act here?"
+    asked the same way every time, instead of scattered ``if`` statements."""
+    model_config = ConfigDict(frozen=True)
+
+    required_scope: str | None = None       # None = any scope (rare; prefer naming one)
+    required_tier: Tier = "act"
+    active_status: str = "active"           # the caller's word for "live", verbatim
+
+    def permits(self, contract: Contract) -> bool:
+        if contract.status != self.active_status:
+            return False
+        if self.required_scope is not None and contract.scope != self.required_scope:
+            return False
+        return _TIER_RANK[contract.tier] >= _TIER_RANK[self.required_tier]
+
+
+class ContractBook(BaseModel):
+    """The parsed book. ``granted(gate)`` answers the only question the executor may ask:
+    which contracts may act, and what exactly does each allow."""
+    model_config = ConfigDict(frozen=True)
+
+    contracts: tuple[Contract, ...] = ()
+
+    @classmethod
+    def load(cls, path: Path | str) -> "ContractBook":
+        """Parse a ``contracts:`` YAML file. Raises on absence or malformation — the caller
+        decides whether that halts startup or degrades to observe-only, but it is never
+        silently treated as an empty (or worse, permissive) book."""
+        doc = yaml.safe_load(Path(path).read_text(encoding="utf-8"))
+        if not isinstance(doc, dict) or "contracts" not in doc:
+            raise ValueError(f"{path}: expected a top-level 'contracts' list")
+        return cls(contracts=tuple(Contract(**e) for e in doc["contracts"]))
+
+    def granted(self, gate: Gate) -> dict[str, tuple[str, ...]]:
+        return {c.name: c.allows for c in self.contracts if gate.permits(c)}

bounded_agent/envelope.py

@@ -0,0 +1,49 @@
+"""Chapter 5 — The safety envelope: the gates every autonomous action passes through.
+
+Four invariants, one small object. They read as paranoia until the first time an unattended
+loop misbehaves; then they read as the minimum:
+
+- **Ships disarmed.** ``armed=False`` is the constructor default. Autonomy is switched on
+  per deployment by a human, after the agent has earned a track record in observe/propose
+  mode — never on by virtue of the code existing.
+- **Kill-switch.** A sentinel *file*, checked before anything runs. Files beat config flags
+  here: an operator (or another watchdog) can stop the agent out-of-band with ``touch STOP``,
+  with no deploy, no restart, no working control plane required.
+- **Per-run breaker.** A hard cap on actions per run. Whatever goes wrong — a looping model,
+  a pathological finding, a bug — the blast radius is N actions and then a halt, not an
+  unbounded cascade.
+- **Act-then-report.** Every action (including refusals and halts) goes through ``notify``.
+  An autonomous agent whose actions can be silent is unauditable; silence must be
+  *structurally impossible*, not a logging convention.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Callable
+
+from pydantic import BaseModel, ConfigDict
+
+
+def _noop(_msg: str) -> None:
+    return None
+
+
+class Envelope(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True, frozen=True)
+
+    armed: bool = False
+    kill_switch_path: Path | None = None
+    max_actions_per_run: int = 1
+    notify: Callable[[str], None] = _noop
+
+    def blocked_reason(self) -> str | None:
+        """Why NO action may run right now; ``None`` means clear to act."""
+        if not self.armed:
+            return "disarmed"
+        if self.kill_switch_path is not None and self.kill_switch_path.exists():
+            return "kill-switch"
+        return None
+
+    def breaker_tripped(self, executed: int) -> bool:
+        """True once ``executed`` actions have already run this run — the next is refused."""
+        return executed >= self.max_actions_per_run

bounded_agent/leaf.py

@@ -0,0 +1,63 @@
+"""Chapter 2 — The typed leaf & the escalate-only floor.
+
+This is the ONLY place the library touches an LLM, and the design point is what it does
+*around* the call, not the call itself:
+
+- **The leaf wraps a** ``pydantic_ai.Agent``, which already guarantees the model's output is
+  a validated instance of your type (or a typed failure). We do not rebuild that — the typed
+  call is a solved problem.
+- **Error-as-value.** ``TypedLeaf.run`` returns your output type OR a ``LeafError`` — an API
+  outage, timeout, or refusal becomes a *value* the control loop folds into its verdict
+  (typically "cannot assess"), never an exception ripping through an unattended process.
+  An autonomous agent that crashes on a provider hiccup is an agent that silently stops
+  watching.
+- **The escalate-only floor.** When an LLM shares a verdict with deterministic checks, the
+  merge rule must be asymmetric: the model may *raise* the alarm level (it noticed something
+  the checks cannot see), but it may never *lower* one (a plausible-sounding "all fine" must
+  not silence a failing probe). ``escalate_only`` is that rule as a function — write it once,
+  test it once, and every leaf in the system inherits the property.
+"""
+from __future__ import annotations
+
+from typing import Any, Callable, Generic, Protocol, TypeVar
+
+from pydantic import BaseModel, ConfigDict
+
+OutputT = TypeVar("OutputT")
+T = TypeVar("T")
+
+
+class LeafError(BaseModel):
+    """A failed leaf run, as a value. The caller decides its verdict weight — the safe
+    default is 'at least cannot-assess', never 'ignore'."""
+    model_config = ConfigDict(frozen=True)
+
+    kind: str        # exception type name
+    detail: str
+
+
+class _Runnable(Protocol):
+    """Structurally, all we need from a pydantic_ai.Agent."""
+    def run_sync(self, prompt: str, *, deps: Any = ...) -> Any: ...
+
+
+class TypedLeaf(Generic[OutputT]):
+    """Wraps an ``Agent[..., OutputT]``; ``run`` returns ``OutputT | LeafError``."""
+
+    def __init__(self, agent: _Runnable) -> None:
+        self._agent = agent
+
+    def run(self, prompt: str, *, deps: Any = None) -> OutputT | LeafError:
+        try:
+            return self._agent.run_sync(prompt, deps=deps).output
+        except Exception as e:  # noqa: BLE001 — the whole point: failure is a value
+            return LeafError(kind=type(e).__name__, detail=str(e))
+
+
+def escalate_only(floor: T, proposed: T | None, *, rank: Callable[[T], int]) -> T:
+    """Merge a deterministic ``floor`` with a leaf's ``proposed`` verdict so the result can
+    only ever be AS BAD OR WORSE than the floor. ``None`` (the leaf declined or errored)
+    keeps the floor. The caller supplies the domain's severity order via ``rank``."""
+    if proposed is None:
+        return floor
+    return proposed if rank(proposed) > rank(floor) else floor

bounded_agent/ledgers.py

@@ -0,0 +1,76 @@
+"""Chapter 4 — Ledgers: append-only evidence, and alerting once instead of forever.
+
+Two small ledgers carry the entire audit story of a bounded agent:
+
+- ``EvidenceLedger`` — **append-only truth.** Every action taken (and refused) and every
+  verdict formed is one JSONL line, partitioned by period. Nothing is ever rewritten; if a
+  later reading disagrees with an earlier one, that disagreement is itself a new line. This
+  is what lets a human audit an unattended agent after the fact — and what makes the agent's
+  own reports checkable against ground truth.
+
+- ``IdempotencyLedger`` — **the anti-alert-rot mechanism.** A finding fingerprint is "new"
+  exactly once per period; repeats are recorded but not re-raised. Alert fatigue is a safety
+  failure — a pager that fires on the same stale finding every run trains its humans to stop
+  reading it, which is how real incidents get ignored.
+
+Both write atomically (tmp + rename) into a directory the agent OWNS — a bounded agent never
+writes outside its own namespace.
+"""
+from __future__ import annotations
+
+import datetime as dt
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel
+
+#: Periods are dates or plain strings ("2026-W31") — the dedup window is the caller's choice.
+Period = dt.date | str
+
+
+def _key(period: Period) -> str:
+    return period.isoformat() if isinstance(period, dt.date) else str(period)
+
+
+class EvidenceLedger:
+    """Append-only JSONL evidence log, partitioned by period."""
+
+    def __init__(self, ledger_dir: Path | str) -> None:
+        self._dir = Path(ledger_dir)
+
+    def append(self, record: BaseModel | dict[str, Any], *, period: Period) -> None:
+        self._dir.mkdir(parents=True, exist_ok=True)
+        payload = record.model_dump() if isinstance(record, BaseModel) else dict(record)
+        with (self._dir / f"{_key(period)}.jsonl").open("a") as f:
+            f.write(json.dumps(payload) + "\n")
+
+
+class IdempotencyLedger:
+    """Fingerprint-per-period dedup with atomic writes."""
+
+    def __init__(self, ledger_dir: Path | str) -> None:
+        self._dir = Path(ledger_dir)
+
+    def _path(self, period: Period) -> Path:
+        return self._dir / f"seen_{_key(period)}.json"
+
+    def seen(self, period: Period) -> set[str]:
+        p = self._path(period)
+        if not p.exists():
+            return set()
+        return set(json.loads(p.read_text()).get("fingerprints", []))
+
+    def new_fingerprints(self, period: Period, fingerprints: list[str]) -> list[str]:
+        seen = self.seen(period)
+        return [f for f in fingerprints if f not in seen]
+
+    def record(self, period: Period, fingerprints: list[str]) -> None:
+        self._dir.mkdir(parents=True, exist_ok=True)
+        merged = sorted(self.seen(period) | set(fingerprints))
+        p = self._path(period)
+        tmp = p.with_suffix(".tmp")
+        tmp.write_text(json.dumps({"period": _key(period), "fingerprints": merged},
+                                  indent=2) + "\n")
+        os.replace(tmp, p)      # atomic: a crash never leaves a half-written dedup file

bounded_agent-0.1.0.dist-info/METADATA

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: bounded-agent
+Version: 0.1.0
+Summary: Contract-bounded autonomy for LLM agents: five small primitives that make an agent safe to leave alone.
+Project-URL: Repository, https://github.com/scholih/bounded-agent
+Project-URL: Manifesto, https://medium.com/@scholih/the-edge-is-the-harness-not-the-model-a543abade391
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: pydantic-ai-slim[anthropic]>=2.22.0
+Requires-Dist: pydantic>=2.7
+Requires-Dist: pyyaml>=6.0
+Description-Content-Type: text/markdown
+
+# bounded-agent
+
+**Contract-bounded autonomy for LLM agents: five small primitives that make an agent safe to
+leave alone.**
+
+The model is table stakes. The reliability of an autonomous agent lives in the **harness** —
+the deterministic structure around the LLM that decides what it may see, what it may say, what
+it may do, and what happens when it fails. This library is that harness, reduced to its five
+load-bearing primitives, each ~50 lines, each independently testable, built on top of
+[PydanticAI](https://ai.pydantic.dev) (which already solves the typed-LLM-call problem — we
+don't rebuild it, we add the autonomy layer it deliberately leaves to you).
+
+The design stance, in one sentence: **deterministic spine, agentic leaves** — code you can
+test decides the flow; the LLM reasons inside well-fenced steps and never pilots the loop.
+
+**The manifesto:** [The Edge Is the Harness, Not the Model](https://medium.com/@scholih/the-edge-is-the-harness-not-the-model-a543abade391) — the argument this library implements, and the start of a series that takes each primitive in depth.
+
+## The five primitives
+
+| Module | Primitive | The failure it prevents |
+|---|---|---|
+| `contracts.py` | **Contracts & gates** — a declared book of who may do what, at which autonomy tier (observe / propose / act) | an agent quietly acquiring capabilities nobody signed off on |
+| `leaf.py` | **The typed leaf & the escalate-only floor** — LLM output is a validated type or an error *value*; an LLM may raise an alarm, never silence one | a plausible-sounding model response lowering a deterministic alarm |
+| `actions.py` | **The double-closed action set** — an action runs only if it is both *contracted* and *implemented*; everything else is refused and recorded | prompt-injected or hallucinated actions; silent capability creep |
+| `ledgers.py` | **Evidence & idempotency ledgers** — append-only truth for every action and verdict; a finding alerts once per period, not forever | un-auditable agents; alert fatigue that trains humans to ignore the pager |
+| `envelope.py` | **The safety envelope** — ships disarmed, kill-switch checked before anything runs, a hard per-run breaker, and act-then-report (silence is impossible) | the runaway loop; the agent that did things nobody heard about |
+
+## Quickstart
+
+```bash
+uv add bounded-agent            # or: pip install bounded-agent
+```
+
+```python
+from bounded_agent import ContractBook, Gate, ActionSet, Envelope, EvidenceLedger
+
+book = ContractBook.load("contracts.yaml")            # raises loudly if missing/malformed
+gate = Gate(required_scope="checkout-stack", required_tier="act")
+granted = book.granted(gate)                          # {contract-name: (allowed actions,)}
+
+actions = ActionSet()
+actions.register("restart_worker", restart_worker)    # the implemented closed set
+
+env = Envelope(armed=True, kill_switch_path=Path("STOP"),
+               max_actions_per_run=2, notify=page_the_operator)
+outcome = actions.execute(list(granted.items()), env,
+                          ledger=EvidenceLedger(Path("ledger")), period=today)
+```
+
+An action fires only if it appears in **both** the contract's `allows` list **and** the
+registered set — and only inside an armed envelope with no kill-switch present and breaker
+budget remaining. Everything that happens (and everything refused) is one JSONL line.
+
+For the LLM side, see `examples/sentinel/` — a complete service-health watchdog: deterministic
+probes → an escalate-only LLM verdict → a typed diagnosis → contract-bounded remediation.
+It runs **offline with no API key** (PydanticAI's `TestModel`) so you can study the whole loop
+before connecting a real model.
+
+## What this deliberately is NOT
+
+Stating the non-goals is part of the teaching — most agent failures start with adopting more
+machinery than the problem earns:
+
+- **Not a planner.** No GOAP, no A*-search over preconditions. If you can hardcode the flow,
+  hardcode the flow.
+- **Not a durable-execution engine.** Design your steps idempotent and re-run from clean;
+  reach for Temporal/DBOS only when a mid-run crash would genuinely corrupt or double-charge.
+- **Not a graph framework.** Small fixed pipelines and explicit state machines in plain code
+  beat a graph DSL until your control flow is genuinely graph-shaped.
+- **Not a PydanticAI replacement.** The typed leaf is solved; this is the autonomy layer
+  above it. If PydanticAI grows this layer, this library should shrink.
+
+## Status
+
+A **teaching artifact**, maintained best-effort. The patterns here are extracted from a
+production system that runs unattended daily; the code is written fresh for clarity. Issues
+and discussion welcome; roadmap promises are not made.
+
+## License
+
+MIT

bounded_agent-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+bounded_agent/__init__.py,sha256=ERju5AUMYwJ8zxyUGBT75FFv64qztBgunIGrujKONqA,900
+bounded_agent/actions.py,sha256=E-Ii-Xv1pHSAmUFBvsq5xzYTzycJduoAZS2hd-IEwqE,5117
+bounded_agent/contracts.py,sha256=QNH8ynEctiPjJ1EW8xtaWRn5ykmGMMCzRbLDY_tLjVo,3878
+bounded_agent/envelope.py,sha256=tqdAeTQ91O2sxqh57GOM_ymk9aHYp5zJtMkqLDgbrnU,2091
+bounded_agent/leaf.py,sha256=eQTrQOiVg-9ndmrNABoxH2uCFTbqz1fC7m49HK-IVpg,2823
+bounded_agent/ledgers.py,sha256=zybMFqxxdxzU6YwKBqltmZfnAHbri5rHCfLJswC7jbg,3101
+bounded_agent-0.1.0.dist-info/METADATA,sha256=stUke1wSCoJmB5gNhPG93qysKhPQN6uhJgRgcvn33cc,5292
+bounded_agent-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+bounded_agent-0.1.0.dist-info/licenses/LICENSE,sha256=gO_6kALpgQsz-8F8sXVQRZbYp2Yth785wo9J2c7rfgQ,1070
+bounded_agent-0.1.0.dist-info/RECORD,,

bounded_agent-0.1.0.dist-info/WHEEL

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

bounded_agent-0.1.0.dist-info/licenses/LICENSE

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