agentx-python 0.6.8__tar.gz → 0.6.10__tar.gz

{agentx_python-0.6.8/agentx_python.egg-info → agentx_python-0.6.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentx-python
-Version: 0.6.8
+Version: 0.6.10
 Summary: Official Python SDK for AgentX (https://www.agentx.so/)
 Home-page: https://github.com/AgentX-ai/AgentX-python
 Author: Robin Wang and AgentX Team
@@ -72,6 +72,7 @@ Also see [SDK Developer Docs](https://developers.agentx.so), [API Reference Docs
 - [Production tracing](#production-tracing) — record live agent runs from any framework
 - [Monitor](#monitor) — automatic production monitoring, patterns and signals
 - [Custom agent evaluations](#custom-agent-evaluations) — LLM-as-a-judge, cosine / Jaccard similarity
+- [Self-host](#self-host) — run Trace/Evaluate/Monitor on your own machine instead of the hosted dashboard
 - [Links](#links)
 
 ---
@@ -273,6 +274,12 @@ for signal in client.monitor.signals.list(severity="high"):
     print(signal.summary, signal.occurrence_count)
 ```
 
+Per-agent coverage/threshold settings (sample rate, retention, and threshold overrides like the built-in "Latency regression" pattern's threshold) are `client.monitor.profile.get()`/`.update()`:
+
+```python
+client.monitor.profile.update("agent_123", threshold_overrides={"latencyMs": 15000})
+```
+
 See **[TRACING.md](TRACING.md)** for the complete Monitor guide.
 
 ---
@@ -306,6 +313,25 @@ See **[EVALUATIONS.md](EVALUATIONS.md)** for the full guide — dataset builder,
 
 ---
 
+## Self-host
+
+Prefer to run Trace/Evaluate/Monitor locally instead of the hosted dashboard — no account, bring your own LLM keys? This SDK ships a launcher for [AgentX-trace-eval](https://github.com/AgentX-ai/AgentX-trace-eval), a separate, portable governance engine:
+
+```bash
+agentx-trace-eval --dev
+```
+
+The first run downloads the engine (and dashboard) into `~/.agentx/bin` and prints a local API key; every run after that just starts it. Point this SDK at it instead of the hosted API:
+
+```bash
+export AGENTX_API_BASE_URL=http://localhost:4700/api/v1
+export AGENTX_API_KEY=<printed by agentx-trace-eval on first run>
+```
+
+`agentx-trace-eval` isn't this SDK's own code — the engine itself is a separate, compiled binary, downloaded on demand rather than bundled into this package, so installing `agentx-python` doesn't get any heavier for the (much more common) case of just talking to the hosted AgentX API. See that repo's README for what's included, and `AGENTX_INSTALL_DIR`/`AGENTX_TRACE_EVAL_VERSION`/`AGENTX_TRACE_EVAL_SKIP_WEB` env vars to control where/what it installs.
+
+---
+
 ## Links
 
 - **Dashboard** — [app.agentx.so](https://app.agentx.so)
@@ -314,3 +340,4 @@ See **[EVALUATIONS.md](EVALUATIONS.md)** for the full guide — dataset builder,
 - **Tracing docs** — [TRACING.md](TRACING.md)
 - **Evaluations docs** — [EVALUATIONS.md](EVALUATIONS.md)
 - **Monitor docs** — [docs.agentx.so/sdk/monitor](https://docs.agentx.so/sdk/monitor)
+- **Self-host** — [AgentX-trace-eval](https://github.com/AgentX-ai/AgentX-trace-eval)

{agentx_python-0.6.8 → agentx_python-0.6.10}/README.md

@@ -24,6 +24,7 @@ Also see [SDK Developer Docs](https://developers.agentx.so), [API Reference Docs
 - [Production tracing](#production-tracing) — record live agent runs from any framework
 - [Monitor](#monitor) — automatic production monitoring, patterns and signals
 - [Custom agent evaluations](#custom-agent-evaluations) — LLM-as-a-judge, cosine / Jaccard similarity
+- [Self-host](#self-host) — run Trace/Evaluate/Monitor on your own machine instead of the hosted dashboard
 - [Links](#links)
 
 ---
@@ -225,6 +226,12 @@ for signal in client.monitor.signals.list(severity="high"):
     print(signal.summary, signal.occurrence_count)
 ```
 
+Per-agent coverage/threshold settings (sample rate, retention, and threshold overrides like the built-in "Latency regression" pattern's threshold) are `client.monitor.profile.get()`/`.update()`:
+
+```python
+client.monitor.profile.update("agent_123", threshold_overrides={"latencyMs": 15000})
+```
+
 See **[TRACING.md](TRACING.md)** for the complete Monitor guide.
 
 ---
@@ -258,6 +265,25 @@ See **[EVALUATIONS.md](EVALUATIONS.md)** for the full guide — dataset builder,
 
 ---
 
+## Self-host
+
+Prefer to run Trace/Evaluate/Monitor locally instead of the hosted dashboard — no account, bring your own LLM keys? This SDK ships a launcher for [AgentX-trace-eval](https://github.com/AgentX-ai/AgentX-trace-eval), a separate, portable governance engine:
+
+```bash
+agentx-trace-eval --dev
+```
+
+The first run downloads the engine (and dashboard) into `~/.agentx/bin` and prints a local API key; every run after that just starts it. Point this SDK at it instead of the hosted API:
+
+```bash
+export AGENTX_API_BASE_URL=http://localhost:4700/api/v1
+export AGENTX_API_KEY=<printed by agentx-trace-eval on first run>
+```
+
+`agentx-trace-eval` isn't this SDK's own code — the engine itself is a separate, compiled binary, downloaded on demand rather than bundled into this package, so installing `agentx-python` doesn't get any heavier for the (much more common) case of just talking to the hosted AgentX API. See that repo's README for what's included, and `AGENTX_INSTALL_DIR`/`AGENTX_TRACE_EVAL_VERSION`/`AGENTX_TRACE_EVAL_SKIP_WEB` env vars to control where/what it installs.
+
+---
+
 ## Links
 
 - **Dashboard** — [app.agentx.so](https://app.agentx.so)
@@ -266,3 +292,4 @@ See **[EVALUATIONS.md](EVALUATIONS.md)** for the full guide — dataset builder,
 - **Tracing docs** — [TRACING.md](TRACING.md)
 - **Evaluations docs** — [EVALUATIONS.md](EVALUATIONS.md)
 - **Monitor docs** — [docs.agentx.so/sdk/monitor](https://docs.agentx.so/sdk/monitor)
+- **Self-host** — [AgentX-trace-eval](https://github.com/AgentX-ai/AgentX-trace-eval)

{agentx_python-0.6.8 → agentx_python-0.6.10}/agentx/agentx.py

@@ -44,7 +44,9 @@ class AgentX:
 
         # Monitor: create/reuse patterns (client.monitor.patterns) that a trace can be checked
         # against at send time via tracer.trace(..., monitor=True, pattern_ids=[...]), then read
-        # back the resulting alerts/findings with client.monitor.signals.
+        # back the resulting alerts/findings with client.monitor.signals. Per-agent coverage and
+        # detection settings (sample rate, retention, threshold overrides like the built-in
+        # "Latency regression" pattern's threshold) are client.monitor.profile.
         self.monitor = MonitorClient(
             api_key=self.api_key,
             sdk_version=VERSION,

agentx_python-0.6.10/agentx/cli.py

@@ -0,0 +1,158 @@
+"""
+`agentx-trace-eval` — thin launcher for AgentX's self-hostable governance engine (Trace,
+Evaluate, Monitor), published separately at github.com/AgentX-ai/AgentX-trace-eval (a Go CLI
+wrapping a Bun-compiled TypeScript engine, not Python). That compiled engine binary is tens of
+megabytes; most `pip install agentx-python` installs are just this SDK talking to the hosted
+AgentX SaaS and would never touch it, so it isn't bundled in this package. Instead, this command
+downloads the matching release into ~/.agentx/bin the first time it's needed (mirroring
+AgentX-trace-eval's own install.sh) and then hands off to the real `agentx-server` binary.
+
+Usage:
+    agentx-trace-eval --dev
+    agentx-trace-eval --port 5000 --db-url postgres://...
+"""
+
+import os
+import platform
+import shutil
+import stat
+import sys
+import tarfile
+import tempfile
+from pathlib import Path
+from typing import Tuple
+
+import requests
+
+REPO = "AgentX-ai/AgentX-trace-eval"
+INSTALL_DIR = Path(os.environ.get("AGENTX_INSTALL_DIR", str(Path.home() / ".agentx" / "bin")))
+_BIN_NAMES = ("agentx", "agentx-server", "agentx-engine")
+
+
+def _platform_tag() -> Tuple[str, str]:
+    system = platform.system()
+    if system == "Darwin":
+        os_name = "darwin"
+    elif system == "Linux":
+        os_name = "linux"
+    else:
+        raise SystemExit(
+            f"agentx-trace-eval: unsupported OS {system!r} (self-host currently supports macOS and Linux)"
+        )
+
+    machine = platform.machine().lower()
+    if machine in ("arm64", "aarch64"):
+        arch = "arm64"
+    elif machine in ("x86_64", "amd64"):
+        arch = "amd64"
+    else:
+        raise SystemExit(f"agentx-trace-eval: unsupported architecture {machine!r}")
+
+    return os_name, arch
+
+
+def _release_url(asset: str, version: str) -> str:
+    if version == "latest":
+        return f"https://github.com/{REPO}/releases/latest/download/{asset}"
+    return f"https://github.com/{REPO}/releases/download/{version}/{asset}"
+
+
+def _download(url: str, dest: Path) -> None:
+    response = requests.get(url, stream=True, timeout=60)
+    response.raise_for_status()
+    with open(dest, "wb") as f:
+        for chunk in response.iter_content(chunk_size=1 << 16):
+            f.write(chunk)
+
+
+def _extract_tar(archive: Path, dest_dir: Path) -> None:
+    with tarfile.open(archive) as tar:
+        try:
+            # filter="data" (PEP 706, Python 3.12+) rejects absolute paths/symlink escapes.
+            # Belt-and-suspenders here since these are trusted release assets built by our own CI
+            # (see REPO above), not arbitrary user-supplied archives.
+            tar.extractall(dest_dir, filter="data")
+        except TypeError:
+            tar.extractall(dest_dir)  # Python < 3.12: filter kwarg doesn't exist yet
+
+
+def _install(version: str = "latest") -> None:
+    os_name, arch = _platform_tag()
+    INSTALL_DIR.mkdir(parents=True, exist_ok=True)
+
+    print(f"agentx-trace-eval: downloading agentx ({os_name}/{arch})...", file=sys.stderr)
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp_dir = Path(tmp)
+        archive = tmp_dir / "agentx.tar.gz"
+        url = _release_url(f"agentx_{os_name}_{arch}.tar.gz", version)
+        try:
+            _download(url, archive)
+        except requests.HTTPError as exc:
+            raise SystemExit(
+                f"agentx-trace-eval: failed to download {url} ({exc}).\n"
+                "No published release found; see AgentX-trace-eval's README for building from source."
+            )
+
+        _extract_tar(archive, tmp_dir)
+
+        found_any = False
+        for name in _BIN_NAMES:
+            src = tmp_dir / name
+            if not src.exists():
+                continue
+            found_any = True
+            dest = INSTALL_DIR / name
+            shutil.move(str(src), str(dest))
+            dest.chmod(dest.stat().st_mode | stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH)
+
+        if not found_any:
+            raise SystemExit(f"agentx-trace-eval: downloaded archive from {url} didn't contain any of {_BIN_NAMES}")
+
+    if os.environ.get("AGENTX_TRACE_EVAL_SKIP_WEB"):
+        return
+
+    # Best-effort: the dashboard is a separate, platform-independent asset (see
+    # AgentX-trace-eval's README's "Dashboard release"). Missing it shouldn't block getting the
+    # engine running headless, so a failure here warns and continues rather than raising.
+    print("agentx-trace-eval: downloading dashboard...", file=sys.stderr)
+    web_dir = INSTALL_DIR / "web"
+    with tempfile.TemporaryDirectory() as tmp:
+        web_archive = Path(tmp) / "agentx-web.tar.gz"
+        web_url = _release_url("agentx-web.tar.gz", version)
+        try:
+            _download(web_url, web_archive)
+        except requests.HTTPError:
+            print(
+                f"agentx-trace-eval: no dashboard bundle found at {web_url}, continuing without one",
+                file=sys.stderr,
+            )
+            return
+        if web_dir.exists():
+            shutil.rmtree(web_dir)
+        web_dir.mkdir(parents=True)
+        _extract_tar(web_archive, web_dir)
+
+
+def ensure_installed(version: str = "latest") -> Path:
+    """Downloads agentx-server (+ its engine) into ~/.agentx/bin if not already present there.
+    Returns the path to the agentx-server executable. Set AGENTX_INSTALL_DIR to change where
+    this looks/installs; set AGENTX_TRACE_EVAL_VERSION to pin a release tag instead of latest."""
+    server_path = INSTALL_DIR / "agentx-server"
+    if not server_path.exists():
+        _install(version=version)
+    return server_path
+
+
+def main() -> None:
+    version = os.environ.get("AGENTX_TRACE_EVAL_VERSION", "latest")
+    server_path = ensure_installed(version=version)
+    if not server_path.exists():
+        raise SystemExit(f"agentx-trace-eval: {server_path} still missing after install, giving up")
+
+    # os.execv replaces this process rather than spawning a subprocess: signals, stdio, and the
+    # exit code all pass straight through to agentx-server, same as invoking it directly.
+    os.execv(str(server_path), [str(server_path)] + sys.argv[1:])
+
+
+if __name__ == "__main__":
+    main()

{agentx_python-0.6.8 → agentx_python-0.6.10}/agentx/integrations/langchain.py

@@ -20,6 +20,7 @@ Requires: ``pip install "agentx-python[langchain]"``
 """
 from __future__ import annotations
 
+import threading
 import time
 from typing import Any, Dict, List, Optional, Union
 from uuid import UUID
@@ -262,6 +263,13 @@ class AgentXCallbackHandler(BaseCallbackHandler):
         self._pending_retrieval_steps: List[Dict[str, Any]] = []
         # run_id → {"start": float, "query": str}
         self._retrieval_starts: Dict[UUID, Dict[str, Any]] = {}
+        # Guards appends to a top-level run's shared aggregate lists (tool_calls,
+        # perf_tool_calls, execution_steps, retrieval_steps). LangGraph's ToolNode
+        # runs multiple tool calls from one AIMessage concurrently via a thread
+        # pool (see langgraph.prebuilt.tool_node.ToolNode._func), so on_tool_end /
+        # on_tool_error can fire from several threads at once for the same
+        # top-level run.
+        self._state_lock = threading.Lock()
 
     # ------------------------------------------------------------------
     # Chain lifecycle
@@ -311,14 +319,14 @@ class AgentXCallbackHandler(BaseCallbackHandler):
             return
         latency_ms = int((time.time() - state["start"]) * 1000)
         output = _extract_output(outputs)
+        # Each tool_call dict already carries its own start_time/end_time (set in
+        # on_tool_end/on_tool_error), so no re-pairing against perf_tool_calls by
+        # index is needed here. That used to be done via zip(), which silently
+        # mispaired timestamps when LangGraph's ToolNode ran several tool calls
+        # from one AIMessage concurrently (see _state_lock's docstring): two
+        # lists appended to from different threads don't necessarily end up in
+        # the same relative order.
         tool_calls = state["tool_calls"] or _extract_tool_calls_from_messages(outputs)
-        if state["tool_calls"] and len(state["tool_calls"]) == len(state["perf_tool_calls"]):
-            # Enrich with the timestamps perf_tool_calls tracked in lockstep,
-            # so tool calls interleave correctly in a merged span's timeline.
-            tool_calls = [
-                {**tc, "start_time": perf.get("start_time"), "end_time": perf.get("end_time")}
-                for tc, perf in zip(state["tool_calls"], state["perf_tool_calls"])
-            ]
 
         active_span = self._tracer.current_span
         if active_span is not None:
@@ -332,6 +340,7 @@ class AgentXCallbackHandler(BaseCallbackHandler):
                 input=state["input"],
                 output=output,
                 model=state.get("model"),
+                framework="langchain",
                 input_tokens=state["input_tokens"] or None,
                 output_tokens=state["output_tokens"] or None,
             )
@@ -383,6 +392,7 @@ class AgentXCallbackHandler(BaseCallbackHandler):
                 retrieval_steps=state["retrieval_steps"],
                 input=state["input"],
                 model=state.get("model"),
+                framework="langchain",
                 input_tokens=state["input_tokens"] or None,
                 output_tokens=state["output_tokens"] or None,
             )
@@ -485,41 +495,42 @@ class AgentXCallbackHandler(BaseCallbackHandler):
             # Extract token usage from LLMResult for this call
             call_input_tokens: Optional[int] = None
             call_output_tokens: Optional[int] = None
-            if top and top in self._runs:
-                usage = {}
-                if hasattr(response, "llm_output") and isinstance(response.llm_output, dict):
-                    usage = response.llm_output.get("token_usage") or response.llm_output.get("usage") or {}
-                # Also check generations for token counts (some providers put it there)
-                if not usage and hasattr(response, "generations"):
-                    for gen_list in (response.generations or []):
-                        for gen in (gen_list or []):
-                            gen_info = getattr(gen, "generation_info", None) or {}
-                            if gen_info.get("prompt_tokens") or gen_info.get("completion_tokens"):
-                                usage = gen_info
-                                break
-                if usage:
-                    call_input_tokens = int(
-                        usage.get("prompt_tokens") or usage.get("input_tokens") or usage.get("prompt_token_count") or 0
-                    )
-                    call_output_tokens = int(
-                        usage.get("completion_tokens") or usage.get("output_tokens") or usage.get("candidates_token_count") or 0
-                    )
-                    self._runs[top]["input_tokens"] += call_input_tokens
-                    self._runs[top]["output_tokens"] += call_output_tokens
-
-            if start_t is not None and top and top in self._runs:
-                steps = self._runs[top]["execution_steps"]
-                steps.append({
-                    "name": f"LLM Call {len(steps) + 1}",
-                    "duration_ms": (end_t - start_t) * 1000,
-                    "start_time": start_t,
-                    "end_time": end_t,
-                    "model": llm_state.get("model"),
-                    "input": llm_state.get("input"),
-                    "output": _extract_llm_output(response),
-                    "inputTokenSize": call_input_tokens,
-                    "outputTokenSize": call_output_tokens,
-                })
+            with self._state_lock:
+                if top and top in self._runs:
+                    usage = {}
+                    if hasattr(response, "llm_output") and isinstance(response.llm_output, dict):
+                        usage = response.llm_output.get("token_usage") or response.llm_output.get("usage") or {}
+                    # Also check generations for token counts (some providers put it there)
+                    if not usage and hasattr(response, "generations"):
+                        for gen_list in (response.generations or []):
+                            for gen in (gen_list or []):
+                                gen_info = getattr(gen, "generation_info", None) or {}
+                                if gen_info.get("prompt_tokens") or gen_info.get("completion_tokens"):
+                                    usage = gen_info
+                                    break
+                    if usage:
+                        call_input_tokens = int(
+                            usage.get("prompt_tokens") or usage.get("input_tokens") or usage.get("prompt_token_count") or 0
+                        )
+                        call_output_tokens = int(
+                            usage.get("completion_tokens") or usage.get("output_tokens") or usage.get("candidates_token_count") or 0
+                        )
+                        self._runs[top]["input_tokens"] += call_input_tokens
+                        self._runs[top]["output_tokens"] += call_output_tokens
+
+                if start_t is not None and top and top in self._runs:
+                    steps = self._runs[top]["execution_steps"]
+                    steps.append({
+                        "name": f"LLM Call {len(steps) + 1}",
+                        "duration_ms": (end_t - start_t) * 1000,
+                        "start_time": start_t,
+                        "end_time": end_t,
+                        "model": llm_state.get("model"),
+                        "input": llm_state.get("input"),
+                        "output": _extract_llm_output(response),
+                        "inputTokenSize": call_input_tokens,
+                        "outputTokenSize": call_output_tokens,
+                    })
 
     # ------------------------------------------------------------------
     # Tool lifecycle
@@ -561,18 +572,25 @@ class AgentXCallbackHandler(BaseCallbackHandler):
             "input": state["tool_input"],
             "output": str(output),
             "latency_ms": latency_ms,
+            "success": True,
+            # Set directly on the tool_call dict (not just perf_tool_calls below) so
+            # on_chain_end's merged-span path doesn't need to re-pair the two lists by
+            # index later. See _state_lock's docstring for why that used to be unsafe.
+            "start_time": start_t,
+            "end_time": end_t,
         }
         top = self._find_top_ancestor(parent_run_id)
-        if top and top in self._runs:
-            self._runs[top]["tool_calls"].append(tool_call)
-            self._runs[top]["perf_tool_calls"].append({
-                "name": state["tool_name"],
-                "duration_ms": (end_t - start_t) * 1000,
-                "start_time": start_t,
-                "end_time": end_t,
-                "input": state["tool_input"],
-                "output": tool_call["output"],
-            })
+        with self._state_lock:
+            if top and top in self._runs:
+                self._runs[top]["tool_calls"].append(tool_call)
+                self._runs[top]["perf_tool_calls"].append({
+                    "name": state["tool_name"],
+                    "duration_ms": (end_t - start_t) * 1000,
+                    "start_time": start_t,
+                    "end_time": end_t,
+                    "input": state["tool_input"],
+                    "output": tool_call["output"],
+                })
 
     def on_tool_error(
         self,
@@ -593,18 +611,22 @@ class AgentXCallbackHandler(BaseCallbackHandler):
             "input": state.get("tool_input"),
             "output": f"ERROR: {error}",
             "latency_ms": int((end_t - start_t) * 1000),
+            "success": False,
+            "start_time": start_t,
+            "end_time": end_t,
         }
         top = self._find_top_ancestor(parent_run_id)
-        if top and top in self._runs:
-            self._runs[top]["tool_calls"].append(tool_call)
-            self._runs[top]["perf_tool_calls"].append({
-                "name": state.get("tool_name", "unknown"),
-                "duration_ms": (end_t - start_t) * 1000,
-                "start_time": start_t,
-                "end_time": end_t,
-                "input": tool_call["input"],
-                "output": tool_call["output"],
-            })
+        with self._state_lock:
+            if top and top in self._runs:
+                self._runs[top]["tool_calls"].append(tool_call)
+                self._runs[top]["perf_tool_calls"].append({
+                    "name": state.get("tool_name", "unknown"),
+                    "duration_ms": (end_t - start_t) * 1000,
+                    "start_time": start_t,
+                    "end_time": end_t,
+                    "input": tool_call["input"],
+                    "output": tool_call["output"],
+                })
 
     # ------------------------------------------------------------------
     # Retriever lifecycle

{agentx_python-0.6.8 → agentx_python-0.6.10}/agentx/monitor/__init__.py

@@ -1,6 +1,7 @@
 from agentx.monitor.client import MonitorClient
-from agentx.monitor.models import MonitorPattern, MonitorSignal, SignalOccurrence
+from agentx.monitor.models import MonitorPattern, MonitorProfile, MonitorSignal, SignalOccurrence
 from agentx.monitor.patterns import MonitorPatternBuilder, MonitorPatternClient
+from agentx.monitor.profile import MonitorProfileClient
 from agentx.monitor.signals import MonitorSignalClient
 
 __all__ = [
@@ -8,6 +9,8 @@ __all__ = [
     "MonitorPattern",
     "MonitorPatternBuilder",
     "MonitorPatternClient",
+    "MonitorProfile",
+    "MonitorProfileClient",
     "MonitorSignal",
     "SignalOccurrence",
     "MonitorSignalClient",

{agentx_python-0.6.8 → agentx_python-0.6.10}/agentx/monitor/client.py

@@ -7,7 +7,7 @@ from typing import Any, List, Optional
 
 import requests
 
-from agentx.monitor.models import MonitorPattern, MonitorSignal
+from agentx.monitor.models import MonitorPattern, MonitorProfile, MonitorSignal
 
 logger = logging.getLogger(__name__)
 
@@ -70,9 +70,11 @@ class MonitorClient:
 
         from agentx.monitor.patterns import MonitorPatternClient
         from agentx.monitor.signals import MonitorSignalClient
+        from agentx.monitor.profile import MonitorProfileClient
 
         self.patterns = MonitorPatternClient(self)
         self.signals = MonitorSignalClient(self)
+        self.profile = MonitorProfileClient(self)
 
     # ------------------------------------------------------------------
     # Low-level HTTP
@@ -166,3 +168,20 @@ class MonitorClient:
             "GET", f"/signals/{signal_id}", params=self._workspace_params()
         )
         return MonitorSignal(**data["signal"])
+
+    # ------------------------------------------------------------------
+    # Profile endpoints
+    # ------------------------------------------------------------------
+
+    def get_profile(self, agent_id: str) -> Optional[MonitorProfile]:
+        data = self._request(
+            "GET", f"/profiles/{agent_id}", params=self._workspace_params()
+        )
+        profile = data.get("profile")
+        return MonitorProfile(**profile) if profile else None
+
+    def update_profile(self, agent_id: str, payload: dict) -> MonitorProfile:
+        data = self._request(
+            "PUT", f"/profiles/{agent_id}", json=self._with_workspace(payload)
+        )
+        return MonitorProfile(**data["profile"])

{agentx_python-0.6.8 → agentx_python-0.6.10}/agentx/monitor/models.py

@@ -51,6 +51,36 @@ class SignalOccurrence(BaseModel):
         extra = "ignore"
 
 
+class MonitorProfile(BaseModel):
+    """A single agent's Monitor coverage/detection settings: what gets sampled, how long it's
+    kept, whether info (clean-run) signals are logged, per-check threshold overrides (e.g.
+    ``threshold_overrides["latencyMs"]`` for the built-in "Latency regression" pattern), and the
+    approval policy gating autotune actions. See ``client.monitor.profile.get()/update()``.
+    ``None`` from ``get()`` means this agent has never been configured and is running on
+    platform defaults (e.g. the built-in latency threshold defaults to 20000ms).
+    """
+
+    id: Optional[str] = Field(default=None, alias="_id")
+    workspace_id: Optional[str] = Field(default=None, alias="workspaceId")
+    agent_id: Optional[Any] = Field(default=None, alias="agentId")
+    enabled: bool = True
+    failure_detection_enabled: bool = Field(default=True, alias="failureDetectionEnabled")
+    info_detection_enabled: bool = Field(default=True, alias="infoDetectionEnabled")
+    coverage_mode: str = Field(default="all", alias="coverageMode")
+    sample_rate: float = Field(default=0.1, alias="sampleRate")
+    channels: List[str] = Field(default_factory=list)
+    threshold_overrides: Optional[Dict[str, Any]] = Field(default=None, alias="thresholdOverrides")
+    retention_days: int = Field(default=30, alias="retentionDays")
+    redaction_mode: str = Field(default="standard", alias="redactionMode")
+    approval_policy: Optional[Dict[str, str]] = Field(default=None, alias="approvalPolicy")
+    created_at: Optional[str] = Field(default=None, alias="createdAt")
+    updated_at: Optional[str] = Field(default=None, alias="updatedAt")
+
+    class Config:
+        populate_by_name = True
+        extra = "ignore"
+
+
 class MonitorSignal(BaseModel):
     """An alert/finding produced when a trace matched a pattern (or, for a "proper" pattern,
     a healthy tally). Read-only from the SDK, see ``client.monitor.signals.list()/get()``, a

agentx_python-0.6.10/agentx/monitor/profile.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional, TYPE_CHECKING
+
+from agentx.monitor.models import MonitorProfile
+
+if TYPE_CHECKING:
+    from agentx.monitor.client import MonitorClient
+
+logger = logging.getLogger(__name__)
+
+
+class MonitorProfileClient:
+    """Thin wrapper surfaced as ``client.monitor.profile``: get/update a single agent's Monitor
+    coverage and detection settings (coverage mode, sample rate, retention, redaction, approval
+    policy, and threshold_overrides, e.g. the built-in "Latency regression" pattern's threshold).
+
+    Unlike patterns/signals, a profile is scoped to one agent per call, since that mirrors how
+    the dashboard's per-agent monitoring settings dialog works: ``get(agent_id)`` returns ``None``
+    for an agent that's never been configured (still on platform defaults), and ``update(agent_id,
+    ...)`` upserts one.
+    """
+
+    def __init__(self, client: "MonitorClient"):
+        self._client = client
+
+    def get(self, agent_id: str) -> Optional[MonitorProfile]:
+        return self._client.get_profile(agent_id)
+
+    def update(
+        self,
+        agent_id: str,
+        *,
+        enabled: Optional[bool] = None,
+        failure_detection_enabled: Optional[bool] = None,
+        info_detection_enabled: Optional[bool] = None,
+        coverage_mode: Optional[str] = None,
+        sample_rate: Optional[float] = None,
+        channels: Optional[List[str]] = None,
+        dataset_id: Optional[str] = None,
+        threshold_overrides: Optional[Dict[str, Any]] = None,
+        retention_days: Optional[int] = None,
+        redaction_mode: Optional[str] = None,
+        approval_policy: Optional[Dict[str, str]] = None,
+    ) -> MonitorProfile:
+        """Update (and enable, if not already) this agent's Monitor profile. Only fields passed
+        here are changed; everything else on the existing profile is left as is.
+
+        Example, overriding the built-in "Latency regression" pattern's threshold for one agent::
+
+            client.monitor.profile.update("agent_123", threshold_overrides={"latencyMs": 15000})
+        """
+        payload: Dict[str, Any] = {
+            "enabled": enabled,
+            "failureDetectionEnabled": failure_detection_enabled,
+            "infoDetectionEnabled": info_detection_enabled,
+            "coverageMode": coverage_mode,
+            "sampleRate": sample_rate,
+            "channels": channels,
+            "datasetId": dataset_id,
+            "thresholdOverrides": threshold_overrides,
+            "retentionDays": retention_days,
+            "redactionMode": redaction_mode,
+            "approvalPolicy": approval_policy,
+        }
+        payload = {k: v for k, v in payload.items() if v is not None}
+        return self._client.update_profile(agent_id, payload)

{agentx_python-0.6.8 → agentx_python-0.6.10}/agentx/tracing/tracer.py

@@ -114,6 +114,9 @@ class _TraceSpan:
         self._execution_steps: list = []
         self._retrieval_steps: list = []
         self._captured_model: Optional[str] = None
+        # Adopted from a merged child run (e.g. AgentXCallbackHandler) when this span itself
+        # wasn't opened with an explicit framework= — see _merge_child_run below.
+        self._captured_framework: Optional[str] = None
         self._input_tokens: int = 0
         self._output_tokens: int = 0
         # Guards _merge_child_run — with Tracer.use_span(), multiple threads
@@ -186,7 +189,7 @@ class _TraceSpan:
             latency_ms=latency_ms,
             error=self._error,
             metadata=self._metadata,
-            framework=self._framework,
+            framework=self._framework or self._captured_framework,
             model=self._model or self._captured_model,
             tool_calls=self.tool_calls or None,
             session_id=self._session_id,
@@ -250,6 +253,7 @@ class _TraceSpan:
         input: Any = None,
         output: Any = None,
         model: Optional[str] = None,
+        framework: Optional[str] = None,
         input_tokens: Optional[int] = None,
         output_tokens: Optional[int] = None,
     ) -> None:
@@ -281,6 +285,8 @@ class _TraceSpan:
                 self.output = output
             if model and not self._captured_model:
                 self._captured_model = model
+            if framework and not self._captured_framework:
+                self._captured_framework = framework
             if input_tokens:
                 self._input_tokens += input_tokens
             if output_tokens:

agentx_python-0.6.10/agentx/version.py

@@ -0,0 +1 @@
+VERSION = "0.6.10"

{agentx_python-0.6.8 → agentx_python-0.6.10/agentx_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentx-python
-Version: 0.6.8
+Version: 0.6.10
 Summary: Official Python SDK for AgentX (https://www.agentx.so/)
 Home-page: https://github.com/AgentX-ai/AgentX-python
 Author: Robin Wang and AgentX Team
@@ -72,6 +72,7 @@ Also see [SDK Developer Docs](https://developers.agentx.so), [API Reference Docs
 - [Production tracing](#production-tracing) — record live agent runs from any framework
 - [Monitor](#monitor) — automatic production monitoring, patterns and signals
 - [Custom agent evaluations](#custom-agent-evaluations) — LLM-as-a-judge, cosine / Jaccard similarity
+- [Self-host](#self-host) — run Trace/Evaluate/Monitor on your own machine instead of the hosted dashboard
 - [Links](#links)
 
 ---
@@ -273,6 +274,12 @@ for signal in client.monitor.signals.list(severity="high"):
     print(signal.summary, signal.occurrence_count)
 ```
 
+Per-agent coverage/threshold settings (sample rate, retention, and threshold overrides like the built-in "Latency regression" pattern's threshold) are `client.monitor.profile.get()`/`.update()`:
+
+```python
+client.monitor.profile.update("agent_123", threshold_overrides={"latencyMs": 15000})
+```
+
 See **[TRACING.md](TRACING.md)** for the complete Monitor guide.
 
 ---
@@ -306,6 +313,25 @@ See **[EVALUATIONS.md](EVALUATIONS.md)** for the full guide — dataset builder,
 
 ---
 
+## Self-host
+
+Prefer to run Trace/Evaluate/Monitor locally instead of the hosted dashboard — no account, bring your own LLM keys? This SDK ships a launcher for [AgentX-trace-eval](https://github.com/AgentX-ai/AgentX-trace-eval), a separate, portable governance engine:
+
+```bash
+agentx-trace-eval --dev
+```
+
+The first run downloads the engine (and dashboard) into `~/.agentx/bin` and prints a local API key; every run after that just starts it. Point this SDK at it instead of the hosted API:
+
+```bash
+export AGENTX_API_BASE_URL=http://localhost:4700/api/v1
+export AGENTX_API_KEY=<printed by agentx-trace-eval on first run>
+```
+
+`agentx-trace-eval` isn't this SDK's own code — the engine itself is a separate, compiled binary, downloaded on demand rather than bundled into this package, so installing `agentx-python` doesn't get any heavier for the (much more common) case of just talking to the hosted AgentX API. See that repo's README for what's included, and `AGENTX_INSTALL_DIR`/`AGENTX_TRACE_EVAL_VERSION`/`AGENTX_TRACE_EVAL_SKIP_WEB` env vars to control where/what it installs.
+
+---
+
 ## Links
 
 - **Dashboard** — [app.agentx.so](https://app.agentx.so)
@@ -314,3 +340,4 @@ See **[EVALUATIONS.md](EVALUATIONS.md)** for the full guide — dataset builder,
 - **Tracing docs** — [TRACING.md](TRACING.md)
 - **Evaluations docs** — [EVALUATIONS.md](EVALUATIONS.md)
 - **Monitor docs** — [docs.agentx.so/sdk/monitor](https://docs.agentx.so/sdk/monitor)
+- **Self-host** — [AgentX-trace-eval](https://github.com/AgentX-ai/AgentX-trace-eval)

{agentx_python-0.6.8 → agentx_python-0.6.10}/agentx_python.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ README.md
 setup.py
 agentx/__init__.py
 agentx/agentx.py
+agentx/cli.py
 agentx/exceptions.py
 agentx/py.typed
 agentx/util.py
@@ -34,6 +35,7 @@ agentx/monitor/__init__.py
 agentx/monitor/client.py
 agentx/monitor/models.py
 agentx/monitor/patterns.py
+agentx/monitor/profile.py
 agentx/monitor/signals.py
 agentx/resources/__init__.py
 agentx/resources/agent.py
@@ -46,6 +48,7 @@ agentx/tracing/tracer.py
 agentx_python.egg-info/PKG-INFO
 agentx_python.egg-info/SOURCES.txt
 agentx_python.egg-info/dependency_links.txt
+agentx_python.egg-info/entry_points.txt
 agentx_python.egg-info/not-zip-safe
 agentx_python.egg-info/requires.txt
 agentx_python.egg-info/top_level.txt

agentx_python-0.6.10/agentx_python.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+agentx-trace-eval = agentx.cli:main

{agentx_python-0.6.8 → agentx_python-0.6.10}/setup.py

@@ -26,6 +26,12 @@ setup(
     # checking for anything that touches the SDK.
     package_data={"agentx": ["py.typed"]},
     zip_safe=False,
+    entry_points={
+        # Thin launcher for the self-hostable governance engine (AgentX-ai/AgentX-trace-eval),
+        # not this SDK itself, see agentx/cli.py's module docstring for why it lazily downloads
+        # rather than bundling that engine in this package.
+        "console_scripts": ["agentx-trace-eval=agentx.cli:main"],
+    },
     install_requires=[
         "urllib3>=1.26.11",
         "certifi",

agentx_python-0.6.8/agentx/version.py

@@ -1 +0,0 @@
-VERSION = "0.6.8"