tide-runtime 0.2.5__tar.gz

tide_runtime-0.2.5/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: tide-runtime
+Version: 0.2.5
+Summary: Tide runtime policy, approvals, and earned-use ledger for AI agent tools.
+Project-URL: Repository, https://github.com/rippletideco/rippletide-package
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Tide Runtime SDK
+
+Python SDK for wrapping production agent tools with Tide policy, approvals, and
+earned-use logging.
+
+```bash
+pip install tide-runtime
+tide ledger init
+```
+
+```python
+from tide import configure, controlled_tool, record_outcome
+
+configure(agent_id="crm-agent", workflow_id="lead-sync", environment="prod")
+
+@controlled_tool(name="crm.update_lead", risk_class="internal_write", capture=["lead_id"])
+def update_lead(lead_id, status):
+    return {"lead_id": lead_id, "status": status}
+
+try:
+    update_lead("L-1", "qualified")
+    record_outcome("success")
+except Exception:
+    record_outcome("failure")
+    raise
+```
+
+Default files live in `.tide/ledger/`. Override with `TIDE_LEDGER_DIR` or
+`configure(project="...")`.

tide_runtime-0.2.5/README.md

@@ -0,0 +1,29 @@
+# Tide Runtime SDK
+
+Python SDK for wrapping production agent tools with Tide policy, approvals, and
+earned-use logging.
+
+```bash
+pip install tide-runtime
+tide ledger init
+```
+
+```python
+from tide import configure, controlled_tool, record_outcome
+
+configure(agent_id="crm-agent", workflow_id="lead-sync", environment="prod")
+
+@controlled_tool(name="crm.update_lead", risk_class="internal_write", capture=["lead_id"])
+def update_lead(lead_id, status):
+    return {"lead_id": lead_id, "status": status}
+
+try:
+    update_lead("L-1", "qualified")
+    record_outcome("success")
+except Exception:
+    record_outcome("failure")
+    raise
+```
+
+Default files live in `.tide/ledger/`. Override with `TIDE_LEDGER_DIR` or
+`configure(project="...")`.

tide_runtime-0.2.5/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tide-runtime"
+version = "0.2.5"
+description = "Tide runtime policy, approvals, and earned-use ledger for AI agent tools."
+requires-python = ">=3.8"
+readme = "README.md"
+
+[project.urls]
+Repository = "https://github.com/rippletideco/rippletide-package"
+
+[tool.setuptools]
+packages = ["tide"]

tide_runtime-0.2.5/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tide_runtime-0.2.5/tests/test_runtime.py

@@ -0,0 +1,184 @@
+import json
+import os
+import shutil
+import sys
+import tempfile
+import threading
+import time
+import unittest
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import tide
+from tide import policy as tide_policy
+from tide import store as tide_store
+
+
+def events(project):
+    return tide_store.read_jsonl(project, tide_store.EVENTS_FILE)
+
+
+class TideRuntimeTest(unittest.TestCase):
+    def setUp(self):
+        self.project = tempfile.mkdtemp(prefix="tide-ledger-test-")
+        tide.configure(project=self.project, agent_id="test-agent",
+                       workflow_id="test-flow", environment="prod",
+                       on_approval="raise", approval_timeout=5, approval_poll=0.05)
+
+    def tearDown(self):
+        shutil.rmtree(self.project, ignore_errors=True)
+
+    def test_policy_matrix_defaults(self):
+        pol = tide_policy.DEFAULT_POLICY
+        self.assertEqual(tide_policy.decide(pol, "t", "read_only", "prod")[0], "allow")
+        self.assertEqual(tide_policy.decide(pol, "t", "internal_write", "prod")[0], "require_approval")
+        self.assertEqual(tide_policy.decide(pol, "t", "internal_write", "dev")[0], "allow_with_log")
+        self.assertEqual(tide_policy.decide(pol, "t", "destructive", "prod")[0], "block")
+
+    def test_policy_fails_closed(self):
+        pol = tide_policy.DEFAULT_POLICY
+        self.assertEqual(tide_policy.decide(pol, "t", "not_a_class", "prod")[0], "block")
+        self.assertEqual(tide_policy.decide({"decisions": {}}, "t", "read_only", "prod")[0], "block")
+
+    def test_per_tool_override_wins(self):
+        pol = json.loads(json.dumps(tide_policy.DEFAULT_POLICY))
+        pol["tools"] = {"crm.nuke": {"decision": "block", "reason": "never"}}
+        decision, reason = tide_policy.decide(pol, "crm.nuke", "read_only", "prod")
+        self.assertEqual(decision, "block")
+        self.assertEqual(reason, "never")
+
+    def test_dynamic_risk_class(self):
+        def classify(named):
+            sql = named["sql"].lower()
+            return "destructive" if "drop " in sql else "read_only"
+
+        @tide.controlled_tool(name="sql.query", risk_class=classify)
+        def query(sql):
+            return "ok"
+
+        self.assertEqual(query("select * from customers"), "ok")
+        with self.assertRaises(tide.LedgerBlocked):
+            query("drop table customers")
+
+    def test_allow_records_event_with_hashes_and_redaction(self):
+        @tide.controlled_tool(name="crm.get_lead", risk_class="read_only", capture=["lead_id"])
+        def get_lead(lead_id, secret_note):
+            return {"lead_id": lead_id, "name": "Ada"}
+
+        result = get_lead("L-1", secret_note="do not store")
+        self.assertEqual(result["name"], "Ada")
+        e = events(self.project)[0]
+        self.assertEqual(e["policy_decision"], "allow")
+        self.assertEqual(e["captured"], {"lead_id": "L-1"})
+        self.assertNotIn("do not store", json.dumps(e))
+        self.assertTrue(e["input_hash"].startswith("sha256:"))
+        self.assertTrue(e["output_hash"].startswith("sha256:"))
+        self.assertIsNone(e["error_code"])
+
+    def test_block_raises_and_records(self):
+        @tide.controlled_tool(name="crm.delete_account", risk_class="destructive")
+        def delete_account(account_id):
+            raise AssertionError("must never run")
+
+        with self.assertRaises(tide.LedgerBlocked):
+            delete_account("A-1")
+        e = events(self.project)[0]
+        self.assertEqual(e["policy_decision"], "block")
+        self.assertEqual(e["error_code"], "blocked_by_policy")
+
+    def test_require_approval_raises_pending_and_records_request(self):
+        @tide.controlled_tool(name="crm.update_lead", risk_class="internal_write")
+        def update_lead(lead_id):
+            return "updated"
+
+        with self.assertRaises(tide.LedgerPending) as ctx:
+            update_lead("L-1")
+        approvals = tide_store.read_jsonl(self.project, tide_store.APPROVALS_FILE)
+        self.assertEqual(approvals[0]["type"], "request")
+        self.assertEqual(approvals[0]["approval_id"], ctx.exception.approval_id)
+        self.assertEqual(events(self.project)[0]["approval_status"], "pending")
+
+    def test_grant_is_hash_bound_and_one_shot(self):
+        @tide.controlled_tool(name="crm.update_lead", risk_class="internal_write")
+        def update_lead(lead_id):
+            return "updated"
+
+        with self.assertRaises(tide.LedgerPending) as ctx:
+            update_lead("L-1")
+        approval_id = ctx.exception.approval_id
+        tide_store.append_jsonl(self.project, tide_store.APPROVALS_FILE, {
+            "type": "decision", "approval_id": approval_id,
+            "decision": "approved", "approver": "tester",
+            "reason": None, "created_at": tide_store.now_iso(),
+        })
+        with self.assertRaises(tide.LedgerPending):
+            update_lead("L-2")
+        self.assertEqual(update_lead("L-1"), "updated")
+        ran = [e for e in events(self.project) if e["approval_status"] == "approved"]
+        self.assertEqual(len(ran), 1)
+        with self.assertRaises(tide.LedgerPending):
+            update_lead("L-1")
+
+    def test_wait_mode_proceeds_after_approval(self):
+        tide.configure(project=self.project, environment="prod",
+                       on_approval="wait", approval_timeout=5, approval_poll=0.05)
+
+        @tide.controlled_tool(name="crm.update_lead", risk_class="internal_write")
+        def update_lead(lead_id):
+            return "updated"
+
+        def approve_soon():
+            time.sleep(0.2)
+            reqs = tide_store.read_jsonl(self.project, tide_store.APPROVALS_FILE)
+            tide_store.append_jsonl(self.project, tide_store.APPROVALS_FILE, {
+                "type": "decision", "approval_id": reqs[0]["approval_id"],
+                "decision": "approved", "approver": "tester",
+                "reason": None, "created_at": tide_store.now_iso(),
+            })
+
+        t = threading.Thread(target=approve_soon)
+        t.start()
+        self.assertEqual(update_lead("L-1"), "updated")
+        t.join()
+        self.assertEqual(events(self.project)[0]["approval_status"], "approved")
+
+    def test_wait_mode_denied_raises(self):
+        tide.configure(project=self.project, environment="prod",
+                       on_approval="wait", approval_timeout=5, approval_poll=0.05)
+
+        @tide.controlled_tool(name="crm.update_lead", risk_class="internal_write")
+        def update_lead(lead_id):
+            raise AssertionError("must never run")
+
+        def deny_soon():
+            time.sleep(0.2)
+            reqs = tide_store.read_jsonl(self.project, tide_store.APPROVALS_FILE)
+            tide_store.append_jsonl(self.project, tide_store.APPROVALS_FILE, {
+                "type": "decision", "approval_id": reqs[0]["approval_id"],
+                "decision": "denied", "approver": "tester",
+                "reason": "not now", "created_at": tide_store.now_iso(),
+            })
+
+        t = threading.Thread(target=deny_soon)
+        t.start()
+        with self.assertRaises(tide.LedgerDenied):
+            update_lead("L-1")
+        t.join()
+        e = events(self.project)[0]
+        self.assertEqual(e["approval_status"], "denied")
+        self.assertEqual(e["error_code"], "approval_denied")
+
+    def test_outcome_links_to_trace(self):
+        @tide.controlled_tool(name="crm.get_lead", risk_class="read_only")
+        def get_lead(lead_id):
+            return "lead"
+
+        get_lead("L-1")
+        tide.record_outcome("success", human_corrected=False)
+        outcome = tide_store.read_jsonl(self.project, tide_store.OUTCOMES_FILE)[0]
+        self.assertEqual(outcome["trace_id"], events(self.project)[0]["trace_id"])
+        self.assertEqual(outcome["status"], "success")
+
+
+if __name__ == "__main__":
+    unittest.main()

tide_runtime-0.2.5/tide/__init__.py

@@ -0,0 +1,250 @@
+"""Tide runtime governance for agent tools with real side effects.
+
+Wrap the tools your agent uses to touch business systems. Before each call a
+deterministic policy decides allow / allow_with_log / require_approval / block;
+every call, approval, and outcome is appended to a local JSONL ledger that the
+`tide ledger` CLI reads.
+
+    from tide import configure, controlled_tool, record_outcome
+
+    configure(agent_id="crm-agent", workflow_id="lead-sync", environment="prod")
+
+    @controlled_tool(name="crm.update_lead", risk_class="internal_write",
+                     capture=["lead_id"])
+    def update_lead(lead_id, status):
+        ...
+
+Zero dependencies, Python >= 3.8. Payloads are hashed by default; `capture`
+opts specific fields into the ledger.
+"""
+
+import functools
+import inspect
+import os
+import time
+
+from . import policy as _policy
+from . import store as _store
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "configure",
+    "controlled_tool",
+    "record_outcome",
+    "LedgerBlocked",
+    "LedgerDenied",
+    "LedgerPending",
+]
+
+
+class LedgerBlocked(Exception):
+    """Policy decision was block; the tool did not run."""
+
+
+class LedgerDenied(Exception):
+    """A human denied the approval request; the tool did not run."""
+
+
+class LedgerPending(Exception):
+    """Approval is pending. Approve via `tide ledger approve <id>` and call again."""
+
+    def __init__(self, approval_id, message):
+        super().__init__(message)
+        self.approval_id = approval_id
+
+
+_config = {
+    "project": os.environ.get("TIDE_LEDGER_DIR", ".tide/ledger"),
+    "agent_id": "agent",
+    "workflow_id": None,
+    "environment": None,
+    "trace_id": None,
+    "on_approval": "wait",
+    "approval_timeout": 300,
+    "approval_poll": 2,
+}
+
+
+def configure(**kwargs):
+    """Set run-level config; starts a new trace unless trace_id is passed."""
+    unknown = set(kwargs) - set(_config)
+    if unknown:
+        raise TypeError("unknown configure() options: %s" % ", ".join(sorted(unknown)))
+    _config.update(kwargs)
+    if not kwargs.get("trace_id"):
+        _config["trace_id"] = _store.new_id()
+    return dict(_config)
+
+
+def _trace_id():
+    if not _config["trace_id"]:
+        _config["trace_id"] = _store.new_id()
+    return _config["trace_id"]
+
+
+def _environment(pol):
+    return (
+        _config["environment"]
+        or os.environ.get("TIDE_ENV")
+        or os.environ.get("LEDGER_ENV")
+        or (pol or {}).get("environment")
+        or "dev"
+    )
+
+
+def _bound_args(fn, args, kwargs):
+    try:
+        bound = inspect.signature(fn).bind(*args, **kwargs)
+        bound.apply_defaults()
+        return dict(bound.arguments)
+    except TypeError:
+        return {"args": list(args), "kwargs": kwargs}
+
+
+def _wait_for_decision(project, approval_id):
+    deadline = time.time() + _config["approval_timeout"]
+    while time.time() < deadline:
+        state = _store.approval_state(project, approval_id)
+        if state == "approved":
+            return "approved"
+        if state == "denied":
+            return "denied"
+        time.sleep(_config["approval_poll"])
+    return "timeout"
+
+
+def record_outcome(status, trace_id=None, workflow_id=None, human_corrected=False,
+                   failure_tag=None, source="api", project=None):
+    """Record what the workflow achieved: usually success or failure."""
+    project = project or _config["project"]
+    record = {
+        "outcome_id": _store.new_id(),
+        "trace_id": trace_id or _trace_id(),
+        "workflow_id": workflow_id or _config["workflow_id"],
+        "status": status,
+        "source": source,
+        "human_corrected": bool(human_corrected),
+        "failure_tag": failure_tag,
+        "created_at": _store.now_iso(),
+    }
+    _store.append_jsonl(project, _store.OUTCOMES_FILE, record)
+    return record
+
+
+def controlled_tool(name, version="0.0.0", risk_class="internal_write", owner=None,
+                    capture=None, cost_usd=None):
+    """Decorator: gate a tool behind policy and record each call."""
+    capture = list(capture or [])
+
+    def decorator(fn):
+        @functools.wraps(fn)
+        def wrapper(*args, **kwargs):
+            project = _config["project"]
+            pol = _store.load_policy(project) or dict(_policy.DEFAULT_POLICY)
+            env = _environment(pol)
+            trace_id = _trace_id()
+            named = _bound_args(fn, args, kwargs)
+            resolved_risk_class = risk_class(named) if callable(risk_class) else risk_class
+            input_hash = _store.canonical_hash(named)
+            captured = {k: named[k] for k in capture if k in named}
+            decision, reason = _policy.decide(pol, name, resolved_risk_class, env)
+
+            event = {
+                "event_id": _store.new_id(),
+                "trace_id": trace_id,
+                "workflow_id": _config["workflow_id"],
+                "agent_id": _config["agent_id"],
+                "tool": name,
+                "tool_version": version,
+                "owner": owner,
+                "risk_class": resolved_risk_class,
+                "environment": env,
+                "input_hash": input_hash,
+                "captured": captured,
+                "policy_decision": decision,
+                "policy_reason": reason,
+                "approval_id": None,
+                "approval_status": None,
+                "output_hash": None,
+                "latency_ms": None,
+                "cost_usd": cost_usd,
+                "error_code": None,
+                "created_at": _store.now_iso(),
+            }
+
+            if decision == "block":
+                event["error_code"] = "blocked_by_policy"
+                _store.append_jsonl(project, _store.EVENTS_FILE, event)
+                raise LedgerBlocked("%s blocked by policy: %s" % (name, reason))
+
+            if decision == "require_approval":
+                grant = _store.find_grant(project, name, input_hash)
+                if grant:
+                    _store.append_jsonl(project, _store.APPROVALS_FILE, {
+                        "type": "consumed",
+                        "approval_id": grant,
+                        "event_id": event["event_id"],
+                        "created_at": _store.now_iso(),
+                    })
+                    event["approval_id"] = grant
+                    event["approval_status"] = "approved"
+                else:
+                    approval_id = _store.new_id()
+                    _store.append_jsonl(project, _store.APPROVALS_FILE, {
+                        "type": "request",
+                        "approval_id": approval_id,
+                        "event_id": event["event_id"],
+                        "trace_id": event["trace_id"],
+                        "tool": name,
+                        "tool_version": version,
+                        "risk_class": resolved_risk_class,
+                        "input_hash": input_hash,
+                        "input_summary": captured,
+                        "policy_reason": reason,
+                        "agent_id": _config["agent_id"],
+                        "workflow_id": _config["workflow_id"],
+                        "created_at": _store.now_iso(),
+                    })
+                    event["approval_id"] = approval_id
+                    hint = "approve with: tide ledger approve %s --project %s" % (approval_id[:8], project)
+                    if _config["on_approval"] == "raise":
+                        event["approval_status"] = "pending"
+                        _store.append_jsonl(project, _store.EVENTS_FILE, event)
+                        raise LedgerPending(approval_id, "%s needs approval - %s" % (name, hint))
+                    result_state = _wait_for_decision(project, approval_id)
+                    if result_state == "denied":
+                        event["approval_status"] = "denied"
+                        event["error_code"] = "approval_denied"
+                        _store.append_jsonl(project, _store.EVENTS_FILE, event)
+                        raise LedgerDenied("%s was denied by a human approver" % name)
+                    if result_state == "timeout":
+                        event["approval_status"] = "pending"
+                        event["error_code"] = "approval_timeout"
+                        _store.append_jsonl(project, _store.EVENTS_FILE, event)
+                        raise LedgerPending(approval_id, "%s approval timed out - %s" % (name, hint))
+                    _store.append_jsonl(project, _store.APPROVALS_FILE, {
+                        "type": "consumed",
+                        "approval_id": approval_id,
+                        "event_id": event["event_id"],
+                        "created_at": _store.now_iso(),
+                    })
+                    event["approval_status"] = "approved"
+
+            start = time.time()
+            try:
+                result = fn(*args, **kwargs)
+            except Exception as exc:
+                event["latency_ms"] = int((time.time() - start) * 1000)
+                event["error_code"] = type(exc).__name__
+                _store.append_jsonl(project, _store.EVENTS_FILE, event)
+                raise
+            event["latency_ms"] = int((time.time() - start) * 1000)
+            event["output_hash"] = _store.canonical_hash(result)
+            _store.append_jsonl(project, _store.EVENTS_FILE, event)
+            return result
+
+        wrapper.__tide__ = {"name": name, "version": version, "risk_class": risk_class, "owner": owner}
+        return wrapper
+
+    return decorator

tide_runtime-0.2.5/tide/policy.py

@@ -0,0 +1,43 @@
+"""Deterministic policy engine: risk class x environment -> decision."""
+
+RISK_CLASSES = (
+    "read_only",
+    "draft_only",
+    "internal_write",
+    "customer_visible",
+    "money_movement",
+    "destructive",
+)
+
+DECISIONS = ("allow", "allow_with_log", "require_approval", "block")
+
+DEFAULT_POLICY = {
+    "version": 1,
+    "environment": "dev",
+    "decisions": {
+        "read_only": {"dev": "allow", "prod": "allow"},
+        "draft_only": {"dev": "allow", "prod": "allow_with_log"},
+        "internal_write": {"dev": "allow_with_log", "prod": "require_approval"},
+        "customer_visible": {"dev": "require_approval", "prod": "require_approval"},
+        "money_movement": {"dev": "require_approval", "prod": "require_approval"},
+        "destructive": {"dev": "require_approval", "prod": "block"},
+    },
+    "tools": {},
+}
+
+
+def decide(policy, tool_name, risk_class, environment):
+    """Return (decision, reason). Per-tool override wins over the class table."""
+    tool_rule = (policy.get("tools") or {}).get(tool_name)
+    if tool_rule:
+        decision = tool_rule.get("decision")
+        if decision in DECISIONS:
+            return decision, tool_rule.get("reason") or ("per-tool override for " + tool_name)
+        return "block", "invalid per-tool override for %s - failing closed" % tool_name
+    table = (policy.get("decisions") or {}).get(risk_class)
+    if not isinstance(table, dict):
+        return "block", "unknown risk class '%s' - failing closed" % risk_class
+    decision = table.get(environment, table.get("prod"))
+    if decision not in DECISIONS:
+        return "block", "no valid decision for %s in '%s' - failing closed" % (risk_class, environment)
+    return decision, "%s in %s -> %s" % (risk_class, environment, decision)

tide_runtime-0.2.5/tide/store.py

@@ -0,0 +1,101 @@
+"""File contract for the Tide ledger directory.
+
+policy.json      policy config
+events.jsonl     one record per controlled tool call
+approvals.jsonl  request / decision / consumed records
+outcomes.jsonl   workflow outcome events
+"""
+
+import hashlib
+import json
+import os
+import uuid
+from datetime import datetime, timezone
+
+POLICY_FILE = "policy.json"
+EVENTS_FILE = "events.jsonl"
+APPROVALS_FILE = "approvals.jsonl"
+OUTCOMES_FILE = "outcomes.jsonl"
+
+
+def now_iso():
+    return datetime.now(timezone.utc).isoformat()
+
+
+def new_id():
+    return uuid.uuid4().hex
+
+
+def canonical_hash(obj):
+    blob = json.dumps(obj, sort_keys=True, separators=(",", ":"), default=str)
+    return "sha256:" + hashlib.sha256(blob.encode("utf-8")).hexdigest()
+
+
+def ensure_project(project):
+    os.makedirs(project, exist_ok=True)
+    return project
+
+
+def load_policy(project):
+    path = os.path.join(project, POLICY_FILE)
+    if not os.path.exists(path):
+        return None
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def append_jsonl(project, filename, record):
+    ensure_project(project)
+    with open(os.path.join(project, filename), "a", encoding="utf-8") as f:
+        f.write(json.dumps(record, sort_keys=True, default=str) + "\n")
+
+
+def read_jsonl(project, filename):
+    path = os.path.join(project, filename)
+    if not os.path.exists(path):
+        return []
+    records = []
+    with open(path, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                records.append(json.loads(line))
+            except ValueError:
+                continue
+    return records
+
+
+def approval_state(project, approval_id):
+    state = None
+    for r in read_jsonl(project, APPROVALS_FILE):
+        if r.get("approval_id") != approval_id:
+            continue
+        kind = r.get("type")
+        if kind == "request":
+            state = "pending"
+        elif kind == "decision":
+            state = "approved" if r.get("decision") == "approved" else "denied"
+        elif kind == "consumed":
+            state = "consumed"
+    return state
+
+
+def find_grant(project, tool_name, input_hash):
+    """Find an approved, unconsumed approval bound to this exact tool and input."""
+    requests = {}
+    for r in read_jsonl(project, APPROVALS_FILE):
+        aid = r.get("approval_id")
+        kind = r.get("type")
+        if kind == "request":
+            requests[aid] = {"record": r, "state": "pending"}
+        elif kind == "decision" and aid in requests:
+            requests[aid]["state"] = "approved" if r.get("decision") == "approved" else "denied"
+        elif kind == "consumed" and aid in requests:
+            requests[aid]["state"] = "consumed"
+    for aid, info in requests.items():
+        req = info["record"]
+        if info["state"] == "approved" and req.get("tool") == tool_name and req.get("input_hash") == input_hash:
+            return aid
+    return None

tide_runtime-0.2.5/tide_runtime.egg-info/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: tide-runtime
+Version: 0.2.5
+Summary: Tide runtime policy, approvals, and earned-use ledger for AI agent tools.
+Project-URL: Repository, https://github.com/rippletideco/rippletide-package
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Tide Runtime SDK
+
+Python SDK for wrapping production agent tools with Tide policy, approvals, and
+earned-use logging.
+
+```bash
+pip install tide-runtime
+tide ledger init
+```
+
+```python
+from tide import configure, controlled_tool, record_outcome
+
+configure(agent_id="crm-agent", workflow_id="lead-sync", environment="prod")
+
+@controlled_tool(name="crm.update_lead", risk_class="internal_write", capture=["lead_id"])
+def update_lead(lead_id, status):
+    return {"lead_id": lead_id, "status": status}
+
+try:
+    update_lead("L-1", "qualified")
+    record_outcome("success")
+except Exception:
+    record_outcome("failure")
+    raise
+```
+
+Default files live in `.tide/ledger/`. Override with `TIDE_LEDGER_DIR` or
+`configure(project="...")`.

tide_runtime-0.2.5/tide_runtime.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+tests/test_runtime.py
+tide/__init__.py
+tide/policy.py
+tide/store.py
+tide_runtime.egg-info/PKG-INFO
+tide_runtime.egg-info/SOURCES.txt
+tide_runtime.egg-info/dependency_links.txt
+tide_runtime.egg-info/top_level.txt

tide_runtime-0.2.5/tide_runtime.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tide_runtime-0.2.5/tide_runtime.egg-info/top_level.txt

@@ -0,0 +1 @@
+tide