agentdynamics 0.4.0__py3-none-any.whl

agentdynamics/pricing.py

@@ -0,0 +1,69 @@
+"""Token pricing (USD per 1M tokens). Anthropic first-party list prices.
+
+Cache writes are billed at 1.25x input (5-minute TTL) or 2x input (1-hour TTL);
+cache reads at 0.1x input. Override any entry via `pricing.json` in the data dir.
+"""
+import json
+import os
+
+# model-id prefix -> (input, output)
+BASE = {
+    "claude-fable-5-1": (10.0, 50.0),
+    "claude-mythos-5-1": (10.0, 50.0),
+    "claude-fable-5": (10.0, 50.0),
+    "claude-opus-5": (5.0, 25.0),
+    "claude-opus-4-8": (5.0, 25.0),
+    "claude-opus-4-7": (5.0, 25.0),
+    "claude-opus-4-6": (5.0, 25.0),
+    "claude-opus-4-5": (5.0, 25.0),
+    "claude-opus-4": (15.0, 75.0),
+    "claude-sonnet-5": (2.0, 10.0),
+    "claude-sonnet-4": (3.0, 15.0),
+    "claude-haiku-4-5": (1.0, 5.0),
+    "claude-3-5-haiku": (0.8, 4.0),
+}
+# Explicit cache-read overrides where the rate is not 0.1x input.
+CACHE_READ_OVERRIDE = {"claude-fable-5-1": 0.25}
+
+_overrides = {}
+
+
+def load_overrides(data_dir):
+    path = os.path.join(data_dir, "pricing.json")
+    if os.path.exists(path):
+        with open(path, encoding="utf-8") as f:
+            _overrides.update(json.load(f))
+
+
+def rates(model):
+    """Return dict of per-1M-token rates for a model id (longest prefix match)."""
+    model = (model or "").lower()
+    if model in _overrides:
+        return _overrides[model]
+    best = None
+    for prefix in BASE:
+        if model.startswith(prefix) and (best is None or len(prefix) > len(best)):
+            best = prefix
+    if best is None:
+        return None
+    inp, out = BASE[best]
+    return {
+        "input": inp,
+        "output": out,
+        "cache_write_5m": inp * 1.25,
+        "cache_write_1h": inp * 2.0,
+        "cache_read": CACHE_READ_OVERRIDE.get(best, inp * 0.1),
+    }
+
+
+def cost(model, input_tokens=0, output_tokens=0, cache_read=0, cache_write_5m=0, cache_write_1h=0):
+    r = rates(model)
+    if not r:
+        return 0.0
+    return (
+        input_tokens * r["input"]
+        + output_tokens * r["output"]
+        + cache_read * r["cache_read"]
+        + cache_write_5m * r["cache_write_5m"]
+        + cache_write_1h * r["cache_write_1h"]
+    ) / 1_000_000

agentdynamics/privacy.py

@@ -0,0 +1,41 @@
+"""PII / secret redaction applied to every stored text field before it reaches the database."""
+import re
+
+PATTERNS = {
+    "email": r"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}",
+    "api_key": r"\b(sk-[A-Za-z0-9_-]{16,}|sk-ant-[A-Za-z0-9_-]{16,}|ghp_[A-Za-z0-9]{20,}|xox[abpr]-[A-Za-z0-9-]{10,}|lsv2_[A-Za-z0-9_]{20,}|AIza[0-9A-Za-z_-]{30,})",
+    "bearer": r"[Bb]earer\s+[A-Za-z0-9._~+/=-]{16,}",
+    "aws_key": r"\bAKIA[0-9A-Z]{16}\b",
+    "credit_card": r"\b(?:\d[ -]?){13,16}\b",
+}
+TEXT_FIELDS = ("text", "input_preview", "error", "target")
+
+
+class Redactor:
+    def __init__(self, privacy_cfg):
+        self.store_content = privacy_cfg.get("store_content", True)
+        pats = [PATTERNS[n] for n in privacy_cfg.get("redact", []) if n in PATTERNS]
+        pats += privacy_cfg.get("extra_patterns", [])
+        self.rx = re.compile("|".join(f"(?:{p})" for p in pats)) if pats else None
+
+    def text(self, s):
+        if not s or not isinstance(s, str):
+            return s
+        if not self.store_content:
+            return f"[content not stored · {len(s)} chars]"
+        return self.rx.sub("[REDACTED]", s) if self.rx else s
+
+    def run(self, run):
+        """Redact in place. Structural fields (names, timings, tokens) are kept."""
+        if self.rx is None and self.store_content:
+            return run
+        run["title"] = self.text(run.get("title"))
+        for s in run.get("steps", []):
+            for f in TEXT_FIELDS:
+                if s.get(f):
+                    # tool targets such as file paths are metadata, keep them unless content storage is off
+                    if f == "target" and self.store_content:
+                        s[f] = self.rx.sub("[REDACTED]", s[f]) if self.rx else s[f]
+                    else:
+                        s[f] = self.text(s[f])
+        return run

agentdynamics/sdk.py

@@ -0,0 +1,105 @@
+"""Tiny tracing SDK for custom agents. Stdlib only.
+
+    tracer = Tracer(agent="support-bot", endpoint="http://127.0.0.1:8787")
+    with tracer.task("Refund order #42") as task:
+        task.record_anthropic(response)             # Anthropic SDK Message
+        with task.tool("lookup_order", {"id": 42}) as call:
+            call.output(result)
+"""
+import json
+import time
+import urllib.request
+import uuid
+
+
+class _ToolCall:
+    def __init__(self, run, name, inp):
+        self.step = {"kind": "tool", "name": name, "input": inp, "ts": time.time(), "is_error": False, "output_chars": 0}
+        run._steps.append(self.step)
+
+    def output(self, value):
+        self.step["output_chars"] = len(value if isinstance(value, str) else json.dumps(value, default=str))
+
+    def error(self, message):
+        self.step["is_error"] = True
+        self.step["error"] = str(message)[:300]
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, et, ev, tb):
+        self.step["end_ts"] = time.time()
+        if ev is not None:
+            self.error(ev)
+        return False
+
+
+class Run:
+    def __init__(self, tracer, prompt, run_id=None, parent_id=None):
+        self.tracer = tracer
+        self.id = run_id or f"{tracer.agent}-{uuid.uuid4().hex[:12]}"
+        self.parent_id = parent_id
+        self._steps = []
+        self._last = time.time()
+        if prompt is not None:
+            self.prompt(prompt)
+
+    def prompt(self, text):
+        """Start a new task inside this run (a follow-up user request)."""
+        self._steps.append({"kind": "prompt", "ts": time.time(), "text": text})
+        self._last = time.time()
+
+    def llm(self, model, input_tokens=0, output_tokens=0, cache_read=0, cache_write=0, stop_reason=None,
+            text="", start_ts=None, end_ts=None, cost=None):
+        end_ts = end_ts or time.time()
+        self._steps.append({"kind": "llm", "model": model, "ts": start_ts or self._last, "end_ts": end_ts,
+                            "input_tokens": input_tokens, "output_tokens": output_tokens, "cache_read": cache_read,
+                            "cache_write": cache_write, "stop_reason": stop_reason, "text": (text or "")[:600], "cost": cost})
+        self._last = end_ts
+
+    def record_anthropic(self, message, start_ts=None):
+        """Record an Anthropic SDK `Message` (or dict) using its usage block."""
+        m = message if isinstance(message, dict) else message.model_dump()
+        u = m.get("usage") or {}
+        text = "".join(b.get("text", "") for b in m.get("content") or [] if b.get("type") == "text")
+        self.llm(m.get("model"), u.get("input_tokens") or 0, u.get("output_tokens") or 0,
+                 u.get("cache_read_input_tokens") or 0, u.get("cache_creation_input_tokens") or 0,
+                 m.get("stop_reason"), text, start_ts=start_ts)
+
+    def tool(self, name, inp=None):
+        return _ToolCall(self, name, inp or {})
+
+    def payload(self):
+        return {"id": self.id, "agent": self.tracer.agent, "project": self.tracer.project, "parent_id": self.parent_id,
+                "source": "sdk", "steps": self._steps}
+
+    def flush(self):
+        return self.tracer.send(self.payload())
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, et, ev, tb):
+        if ev is not None:
+            self._steps.append({"kind": "notice", "name": "api_error", "ts": time.time(), "text": repr(ev)[:300]})
+        try:
+            self.flush()
+        except OSError as ex:  # monitoring must never break the agent
+            print(f"[agentdynamics] could not send run {self.id}: {ex}")
+        return False
+
+
+class Tracer:
+    def __init__(self, agent, project=None, endpoint="http://127.0.0.1:8787"):
+        self.agent = agent
+        self.project = project or agent
+        self.endpoint = endpoint.rstrip("/")
+
+    def task(self, prompt, run_id=None, parent_id=None):
+        return Run(self, prompt, run_id, parent_id)
+
+    def send(self, payload):
+        req = urllib.request.Request(f"{self.endpoint}/api/ingest", data=json.dumps(payload, default=str).encode(),
+                                     headers={"Content-Type": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=10) as r:
+            return json.loads(r.read())