agentx-python 0.8.24__py3-none-any.whl → 0.8.26__py3-none-any.whl

agentx/agentx.py

@@ -20,8 +20,8 @@ class AgentX:
         # The api_key is NOT written back into os.environ (it used to be): every sub-client
         # below receives it explicitly, and mutating process-global state from a constructor
         # re-pointed unrelated code - the same leak the base_url write below had (deep-dive
-        # round 3, bug #1). Static flows that still read the env (AgentX.list_workforces,
-        # bare get_headers()) now require the caller to set AGENTX_API_KEY themselves.
+        # round 3, bug #1). Flows that still read the env (bare get_headers()) now require
+        # the caller to set AGENTX_API_KEY themselves.
         self.api_key = api_key or os.getenv("AGENTX_API_KEY")
 
         # base_url overrides AGENTX_API_BASE_URL env var (and the SDK default). It is
@@ -147,7 +147,7 @@ class AgentX:
         response = requests.get(url, headers=get_headers(self.api_key))
         # Check if response was successful
         if response.status_code == 200:
-            return Agent(**response.json())
+            return Agent(**response.json())._bind(self.api_key, self.base_url)
         else:
             raise AgentXError(
                 f"Failed to retrieve agent: {response.reason}. This endpoint is "
@@ -165,22 +165,26 @@ class AgentX:
         response = requests.get(url, headers=get_headers(self.api_key))
         # Check if response was successful
         if response.status_code == 200:
-            return [Agent(**agent) for agent in response.json()]
+            return [Agent(**agent)._bind(self.api_key, self.base_url) for agent in response.json()]
         else:
             raise AgentXError(
                 f"Failed to list agents: {response.reason}. This endpoint is "
                 "hosted-platform only - on self-host use client.monitor.agents.list()."
             )
 
-    @staticmethod
-    def list_workforces() -> List["Workforce"]:
-        """List all workforces/teams. Static, so it reads AGENTX_API_KEY from the environment
-        directly - the constructor no longer writes ``api_key`` into os.environ, so set the
-        env var yourself before calling this."""
-        url = f"{api_base()}/access/teams"
-        response = requests.get(url, headers=get_headers())
+    def list_workforces(self) -> List["Workforce"]:
+        """List all workforces/teams, each bound to this client's credentials - including each
+        workforce's ``manager`` and ``agents``, so their calls authenticate the same way.
+
+        This used to be documented as a static call (``AgentX.list_workforces()``); that form
+        was broken (the old staticmethod body referenced ``self`` and raised NameError on any
+        non-empty response). Construct a client instead - ``AgentX().list_workforces()`` picks
+        up AGENTX_API_KEY / AGENTX_API_BASE_URL from the environment, which is what the static
+        form effectively did."""
+        url = f"{self.base_url or api_base()}/access/teams"
+        response = requests.get(url, headers=get_headers(self.api_key))
         if response.status_code == 200:
-            return [Workforce(**workforce) for workforce in response.json()]
+            return [Workforce(**workforce)._bind(self.api_key, self.base_url) for workforce in response.json()]
         else:
             raise Exception(
                 f"Failed to list workforces: {response.status_code} - {response.reason}"

agentx/integrations/__init__.py

@@ -7,4 +7,5 @@
 #   from agentx.integrations.anthropic import patch_anthropic_client
 #   from agentx.integrations.google_adk import AgentXADKPlugin
 #   from agentx.integrations.google_genai import patch_genai_client
+#   from agentx.integrations.nvidia_nim import patch_nim_client
 #   from agentx.integrations.moveworks import MoveworksImporter  # Data API pull sync, not in-process

agentx/integrations/crewai.py

@@ -144,14 +144,14 @@ class AgentXCrewObserver:
                     TaskFailedEvent,
                     TaskStartedEvent,
                 )
-            except ImportError:
+            except Exception:  # noqa: BLE001 - crewai import raises TypeError (PEP 604) on py3.9, not just ImportError
                 from crewai.utilities.events import crewai_event_bus
                 from crewai.utilities.events.task_events import (
                     TaskCompletedEvent,
                     TaskFailedEvent,
                     TaskStartedEvent,
                 )
-        except ImportError:
+        except Exception:  # noqa: BLE001 - crewai import raises TypeError (PEP 604) on py3.9, not just ImportError
             if not _warned_no_event_bus:
                 _warned_no_event_bus = True
                 logger.warning(

agentx/integrations/nvidia_nim.py

@@ -0,0 +1,70 @@
+"""
+NVIDIA NIM integration for AgentX production tracing.
+
+NIM (NVIDIA Inference Microservices) serves models behind an OpenAI-compatible
+``/v1/chat/completions`` API, so the client you patch is the ordinary ``openai``
+Python client pointed at a NIM endpoint - a local NIM container
+(``http://localhost:8000/v1``) or NVIDIA's hosted API
+(``https://integrate.api.nvidia.com/v1``). This module reuses the OpenAI patch
+machinery verbatim and differs in exactly one way: traces are stamped
+``framework="nvidia-nim"``, so NIM traffic gets its own row in Monitor's
+Platforms chart and the framework filters instead of blending into "openai".
+
+Usage::
+
+    from agentx.integrations.nvidia_nim import patch_nim_client
+    import openai
+
+    nim = openai.OpenAI(
+        base_url="http://localhost:8000/v1",  # or https://integrate.api.nvidia.com/v1
+        api_key=os.environ.get("NVIDIA_API_KEY", "not-needed-for-local-nim"),
+    )
+    patch_nim_client(nim, agentx.tracer, name="nim-agent")
+
+    # All subsequent nim.chat.completions.create() calls are now traced.
+
+Works with both ``openai.OpenAI`` and ``openai.AsyncOpenAI`` clients. Token
+usage comes straight off the response's OpenAI-shaped ``usage`` block; NIM
+reports no prompt-cache fields, so cache token counts stay unset.
+
+Streaming calls (``stream=True``) are passed through untouched and are not
+currently traced - same posture as ``patch_openai_client``, see its docstring.
+
+Requires: ``pip install "agentx-python[nvidia-nim]"`` (installs the ``openai``
+client package; there is no separate NIM SDK dependency).
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from agentx.tracing.tracer import Tracer
+from agentx.integrations.openai import _patch_chat_completions_create
+
+NIM_FRAMEWORK = "nvidia-nim"
+
+
+def patch_nim_client(
+    client: Any,
+    tracer: Tracer,
+    name: str = "nim-agent",
+    metadata: Optional[Dict[str, Any]] = None,
+    session_id: Optional[str] = None,
+) -> None:
+    """
+    Monkey-patch ``client.chat.completions.create`` on an OpenAI-compatible
+    client pointed at a NIM endpoint, sending a trace for every non-streaming
+    call with ``framework="nvidia-nim"``.
+
+    The original method is still called and its return value passed through
+    unchanged. Sync and async clients both work; ``stream=True`` calls pass
+    through untraced. Patching is idempotent - and because it shares the guard
+    with ``patch_openai_client``, whichever of the two patched a given client
+    first wins (patch each client with the integration that matches where its
+    ``base_url`` actually points).
+    """
+    chat = getattr(client, "chat", None)
+    completions = getattr(chat, "completions", None) if chat is not None else None
+    if completions is None:
+        raise ValueError("Provided client does not have a .chat.completions attribute")
+
+    _patch_chat_completions_create(completions, tracer, name, metadata, session_id, framework=NIM_FRAMEWORK)

agentx/integrations/openai.py

@@ -113,7 +113,11 @@ def _patch_chat_completions_create(
     name: str,
     metadata: Optional[Dict[str, Any]],
     session_id: Optional[str],
+    framework: str = "openai",
 ) -> None:
+    # `framework` exists for OpenAI-compatible endpoints served by other vendors
+    # (agentx.integrations.nvidia_nim stamps "nvidia-nim" through here) - the request/response
+    # shapes are identical, so they share this machinery instead of duplicating it.
     original = completions_resource.create
     if getattr(original, "_agentx_patched", False):
         return  # already patched
@@ -148,7 +152,7 @@ def _patch_chat_completions_create(
             finish_llm_call(
                 tracer,
                 name=name,
-                framework="openai",
+                framework=framework,
                 metadata=metadata,
                 session_id=session_id,
                 start_t=start_t,

agentx/monitor/__init__.py

@@ -10,6 +10,9 @@ from agentx.monitor.judge_scorers import (
 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.review_queue import ReviewQueueClient, ReviewQueueItem
+from agentx.monitor.rules import MonitorRule, MonitorRulesClient
+from agentx.monitor.scorers import AgentXScorersError, ScorersClient
 from agentx.monitor.scorer_groups import AgentXScorerGroupsError, ScorerGroup, ScorerGroupsClient
 from agentx.monitor.sessions import MonitorSessionClient
 from agentx.monitor.signals import MonitorSignalClient
@@ -19,6 +22,7 @@ __all__ = [
     "AgentXJudgeScorersError",
     "AgentXMonitorError",
     "AgentXScorerGroupsError",
+    "AgentXScorersError",
     "ImprovementGroupsClient",
     "JudgeScorer",
     "JudgeScorerBuilder",
@@ -30,10 +34,15 @@ __all__ = [
     "MonitorPatternClient",
     "MonitorProfile",
     "MonitorProfileClient",
+    "MonitorRule",
+    "MonitorRulesClient",
     "MonitorSessionClient",
     "MonitorSignal",
     "MonitorSignalClient",
+    "ReviewQueueClient",
+    "ReviewQueueItem",
     "ScorerGroup",
+    "ScorersClient",
     "ScorerGroupsClient",
     "SignalOccurrence",
 ]

agentx/monitor/_transport.py

@@ -0,0 +1,48 @@
+"""Shared HTTP transport for the monitor sub-clients that own their ``_request`` (scorers,
+judge_scorers, scorer_groups, improvement_groups): one retry schedule mirroring
+``MonitorClient._request``, so ``retry=False`` means the same thing everywhere the client.py
+comment promises it ("retry=False for ANY non-idempotent write")."""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Any, Optional
+
+import requests
+
+logger = logging.getLogger(__name__)
+
+# Same schedule as MonitorClient._request (agentx/monitor/client.py).
+_RETRYABLE_STATUS = {429, 500, 502, 503, 504}
+_RETRY_BACKOFF = [1.0, 2.0, 4.0]
+
+
+def request_with_retries(
+    method: str, url: str, *, retry: bool = True, **kwargs: Any
+) -> requests.Response:
+    """``requests.request`` with MonitorClient's transport posture: when ``retry`` is true,
+    connection errors and retryable statuses (429/5xx) walk the backoff schedule; the last
+    response (whatever its status) is returned for the caller's own error taxonomy.
+
+    ``retry=False`` is single-shot - for non-idempotent writes (creates, deletes) and
+    judge-billing POSTs, where a client-side timeout must not fire the same work twice.
+    Transport errors keep their ``requests`` exception type (callers guard on
+    ``requests.Timeout`` for judge-billing endpoints)."""
+    schedule = [0.0] + _RETRY_BACKOFF if retry else [0.0]
+    last_exc: Optional[Exception] = None
+    for attempt, wait in enumerate(schedule):
+        if wait:
+            time.sleep(wait)
+        try:
+            resp = requests.request(method, url, **kwargs)
+        except requests.RequestException as e:
+            last_exc = e
+            logger.debug("Request error (attempt %d): %s", attempt + 1, e)
+            continue
+        if retry and resp.status_code in _RETRYABLE_STATUS and attempt < len(schedule) - 1:
+            logger.debug("Retryable status %d (attempt %d)", resp.status_code, attempt + 1)
+            continue
+        return resp
+    assert last_exc is not None  # every non-raising path returned above
+    raise last_exc

agentx/monitor/client.py

@@ -205,9 +205,11 @@ class MonitorClient:
     def _request(
         self, method: str, path: str, timeout: int = 30, base: Optional[str] = None, retry: bool = True, **kwargs
     ) -> Any:
-        # retry=False for non-idempotent judge-spending POSTs (sweep, coherence, portability,
-        # tuning): a client-side timeout must not fire the same LLM-billing work a second time
-        # while the first invocation is still running server-side. Same precedent as
+        # retry=False for ANY non-idempotent write - duplicating creates, deletes (a lost
+        # response + retry turns success into a spurious 404), and judge-spending POSTs
+        # (sweep, coherence, portability, tuning: a client-side timeout must not fire the
+        # same LLM-billing work twice while the first invocation still runs server-side).
+        # The judge list is the example set, not the rule. Same precedent as
         # EvaluationsClient._request / analyze_run.
         url = f"{base or self._base_url}{path}"
         last_exc: Optional[Exception] = None

agentx/monitor/improvement_groups.py

@@ -4,6 +4,7 @@ from typing import Any, Dict, List, Optional
 
 import requests
 
+from agentx.monitor._transport import request_with_retries
 from agentx.util import api_base, get_headers
 from agentx.exceptions import AgentXError, AgentXAuthError, AgentXValidationError
 
@@ -45,7 +46,9 @@ class ImprovementGroupsClient:
         self._workspace_id = workspace_id
         self._base_url = (base_url or api_base()).rstrip("/")
 
-    def _request(self, method: str, path: str, json: Any = None, timeout: int = 120) -> Any:
+    def _request(
+        self, method: str, path: str, json: Any = None, timeout: int = 120, retry: bool = True
+    ) -> Any:
         params = None
         if self._workspace_id:
             # Mirrors MonitorClient._workspace_params/_with_workspace: GETs (and DELETEs)
@@ -57,9 +60,12 @@ class ImprovementGroupsClient:
                     json = {**json, "workspaceId": self._workspace_id}
             else:
                 params = {"workspaceId": self._workspace_id}
-        resp = requests.request(
+        # retry=False for ANY non-idempotent write (member deletes, the report-generating
+        # POST) - MonitorClient._request's posture, via the shared monitor transport.
+        resp = request_with_retries(
             method,
             f"{self._base_url}/agent-monitoring{path}",
+            retry=retry,
             headers={**get_headers(self._api_key), "Content-Type": "application/json"},
             json=json,
             params=params,
@@ -92,7 +98,9 @@ class ImprovementGroupsClient:
 
     def remove_member(self, group_id: str, member_id: str) -> None:
         """Prune a member before spending the group (a confirm that turned out uninteresting)."""
-        self._request("DELETE", f"/improvement-groups/{group_id}/members/{member_id}")
+        # retry=False: a lost response + transport retry would turn a successful delete
+        # into a spurious 404.
+        self._request("DELETE", f"/improvement-groups/{group_id}/members/{member_id}", retry=False)
 
     def generate_report(self, group_id: str, model: Optional[str] = None) -> Dict[str, Any]:
         """Spend the group: one real LLM call clustering the confirmed failures into issues
@@ -101,7 +109,11 @@ class ImprovementGroupsClient:
         payload: Dict[str, Any] = {}
         if model is not None:
             payload["model"] = model
-        return self._request("POST", f"/improvement-groups/{group_id}/report", json=payload, timeout=300)["report"]
+        # retry=False: spends the group (real LLM billing) - a client-side timeout must not
+        # fire the same generation twice while the first still runs server-side.
+        return self._request(
+            "POST", f"/improvement-groups/{group_id}/report", json=payload, timeout=300, retry=False
+        )["report"]
 
     def list_reports(self) -> List[Dict[str, Any]]:
         return self._request("GET", "/improvement-reports").get("improvementReports", [])

agentx/monitor/judge_scorers.py

@@ -5,6 +5,7 @@ from typing import Any, Dict, List, Optional
 
 import requests
 
+from agentx.monitor._transport import request_with_retries
 from agentx.util import api_base, get_headers
 from agentx.exceptions import AgentXError, AgentXAuthError, AgentXValidationError
 
@@ -97,7 +98,9 @@ class JudgeScorersClient:
         # Captured once at construction so two clients with different bases can coexist.
         self._base_url = (base_url or api_base()).rstrip("/")
 
-    def _request(self, method: str, path: str, json: Any = None, timeout: int = 60) -> Any:
+    def _request(
+        self, method: str, path: str, json: Any = None, timeout: int = 60, retry: bool = True
+    ) -> Any:
         params = None
         if self._workspace_id:
             # Mirrors MonitorClient._workspace_params/_with_workspace: GETs (and DELETEs)
@@ -109,9 +112,13 @@ class JudgeScorersClient:
                     json = {**json, "workspaceId": self._workspace_id}
             else:
                 params = {"workspaceId": self._workspace_id}
-        resp = requests.request(
+        # retry=False for ANY non-idempotent write (creates, deletes) and judge-spending POST
+        # (tune/validate/publish) - MonitorClient._request's posture, via the shared monitor
+        # transport.
+        resp = request_with_retries(
             method,
             f"{self._base_url}/agent-monitoring{path}",
+            retry=retry,
             headers={**get_headers(self._api_key), "Content-Type": "application/json"},
             json=json,
             params=params,
@@ -263,7 +270,10 @@ class JudgeScorersClient:
             payload["offline"] = offline
         if online is not None:
             payload["online"] = online
-        return JudgeScorer(self._request("POST", "/judge-scorers", json=payload)["judgeScorer"])
+        # Server-side create: a timeout + transport retry would create the scorer twice.
+        return JudgeScorer(
+            self._request("POST", "/judge-scorers", json=payload, retry=False)["judgeScorer"]
+        )
 
     def get(self, scorer_id: str) -> JudgeScorer:
         return JudgeScorer(self._request("GET", f"/judge-scorers/{scorer_id}")["judgeScorer"])
@@ -300,7 +310,9 @@ class JudgeScorersClient:
     def delete(self, scorer_id: str) -> None:
         """Delete the scorer: rubric, version history, and online profile together.
         Irreversible; refused for the built-in Session Baseline Judge."""
-        self._request("DELETE", f"/judge-scorers/{scorer_id}")
+        # retry=False: a lost response + transport retry would turn a successful delete
+        # into a spurious 404.
+        self._request("DELETE", f"/judge-scorers/{scorer_id}", retry=False)
 
     # ------------------------------------------------------------------
     # Online-profile pass-throughs (calibration / tuning / ratings / events)
@@ -334,8 +346,14 @@ class JudgeScorersClient:
     def tune(self, scorer_id: str, window: str = "7d") -> dict:
         """Propose a rewrite of the rubric from calibration disagreements (LLM call, slow).
         ``window`` accepts the same values as :meth:`calibration`, including "rubric"."""
+        # retry=False (judge-spending POST, MonitorClient.propose_online_evaluator_tuning's
+        # posture): a client-side timeout must not fire the same LLM-billing work twice.
         data = self._request(
-            "POST", f"/online-evaluators/{self._profile_id(scorer_id)}/tune", json={"window": window}, timeout=300
+            "POST",
+            f"/online-evaluators/{self._profile_id(scorer_id)}/tune",
+            json={"window": window},
+            timeout=300,
+            retry=False,
         )
         # The wire wraps the proposal ({"proposal": {...}}); unwrap like the legacy client so
         # proposal["reasoning"] / the criteria fields are directly addressable.
@@ -344,11 +362,13 @@ class JudgeScorersClient:
     def validate_tuning(self, scorer_id: str, criteria: Dict[str, Any], window: str = "7d") -> dict:
         """Re-judge the disagreement + control cases with candidate criteria (LLM calls, slow)."""
         # The wire takes the criteria fields at the TOP level of the body, not nested.
+        # retry=False (judge-spending POST) - same posture as tune() above.
         return self._request(
             "POST",
             f"/online-evaluators/{self._profile_id(scorer_id)}/tune/validate",
             json={**criteria, "window": window},
             timeout=600,
+            retry=False,
         )
 
     def publish_tuning(
@@ -382,7 +402,14 @@ class JudgeScorersClient:
             payload["validation"] = validation_payload
         if force:
             payload["force"] = True
-        return self._request("POST", f"/online-evaluators/{self._profile_id(scorer_id)}/tune/publish", json=payload)
+        # retry=False: a non-idempotent write (each publish appends a rubric version) -
+        # MonitorClient.publish_online_evaluator_tuning's posture.
+        return self._request(
+            "POST",
+            f"/online-evaluators/{self._profile_id(scorer_id)}/tune/publish",
+            json=payload,
+            retry=False,
+        )
 
     def ratings(self, scorer_id: str, window: str = "7d") -> "List[OnlineEvaluatorRatingPoint]":
         """Bucketed average-rating-over-time for this scorer's live checks - same typed points

agentx/monitor/patterns.py

@@ -137,16 +137,108 @@ class MonitorPatternClient:
             retry=False,
         )
 
+    # snake_case -> wire camelCase, same posture as rules.update: the engine reads only the
+    # camelCase key and silently keeps the stored value for anything it does not recognize -
+    # update(sample_rate=0.05) used to 200 with the rate unchanged.
+    _UPDATE_ALIASES = {
+        "sample_rate": "sampleRate",
+        "scope_mode": "scopeMode",
+        "agent_ids": "agentIds",
+        "detector_kind": "detectorKind",
+        "include_terms": "includeTerms",
+        "exclude_terms": "excludeTerms",
+        "regex": "regex",
+        "semantic_prompt": "semanticPrompt",
+        "match_mode": "matchMode",
+        "match_target": "matchTarget",
+    }
+
+    # The engine's PUT rebuilds the pattern's WHOLE conditions array (legacyPayloadToConditions:
+    # "a full replace, not a sparse patch") exactly when the body carries one of these - its own
+    # sentConditionFields set, minus "conditions". Bodies without any of them keep the stored
+    # conditions untouched.
+    _TRIGGER_FIELDS = ("includeTerms", "regex", "semanticPrompt")
+
+    # Sent alone, these look sparse but cannot land: without a trigger field the engine never
+    # rebuilds conditions (the values are silently ignored). For excludeTerms/matchMode there is
+    # also nothing to merge them over client-side - the wire GET reports display-only
+    # placeholders (includeTerms/excludeTerms always [], matchMode always "any"; conditions is
+    # the only truth). matchTarget IS reported faithfully, but the engine only reads it during a
+    # rebuild, so alone it is the same silent no-op.
+    _UNMERGEABLE_ALONE = ("excludeTerms", "matchMode", "matchTarget")
+
     def update(self, pattern_id: str, **fields: Any) -> MonitorPattern:
-        """Update a pattern's fields in place (wire camelCase keys, passed through
-        verbatim - e.g. ``enabled=False``, ``conditions=[...]``) and return the
-        updated :class:`MonitorPattern`. retry=False: a non-idempotent server-side
-        write must not be re-fired on a lost response."""
+        """Update a pattern and return the updated :class:`MonitorPattern`. Accepts snake_case
+        kwargs (``sample_rate=0.05``) or the wire's camelCase; an unrecognized snake_case key
+        raises instead of silently changing nothing.
+
+        The real contract on self-host: the stored truth is the pattern's ``conditions`` array,
+        and the flat fields the wire GET returns are display-only placeholders (``includeTerms``/
+        ``excludeTerms`` always ``[]``, ``matchMode`` always ``"any"``, ``regex``/
+        ``semanticPrompt`` omitted). The engine's PUT rebuilds the WHOLE conditions array
+        whenever the body carries ``include_terms``, ``regex``, or ``semantic_prompt`` (or an
+        explicit ``conditions`` list, which wins outright). Consequences:
+
+        - ``update(pid, regex=...)`` (or include_terms/semantic_prompt) is a full detector
+          rewrite; the detector kind follows the trigger field actually sent (``regex`` ->
+          ``"regex"``, ``semantic_prompt`` -> ``"semantic"``, ``include_terms`` ->
+          ``"contains"``), so cross-kind updates work, and this client back-fills only
+          ``matchTarget`` from the stored pattern so the rebuild keeps its target. It never
+          back-fills ``includeTerms``/``excludeTerms``/``matchMode`` - the GET values are
+          placeholders, and copying them in would destroy real conditions.
+        - ``exclude_terms=``, ``match_mode=``, or ``match_target=`` alone raises ValueError:
+          the engine silently ignores them without a rebuild. Pass ``conditions=[...]`` (built
+          from ``get(pattern_id).conditions``) instead, or pass them alongside the
+          include_terms/regex/semantic_prompt they should be rebuilt with.
+        - Everything else stays a sparse metadata edit that leaves the stored conditions
+          untouched."""
+        payload: Dict[str, Any] = {}
+        for key, value in fields.items():
+            wire_key = self._UPDATE_ALIASES.get(key, key)
+            if "_" in wire_key:
+                raise ValueError(
+                    f"Unknown pattern field {key!r} - the engine reads camelCase keys and would "
+                    "silently ignore this (see MonitorPattern for the field names)."
+                )
+            payload[wire_key] = value
+        sends_conditions = "conditions" in payload
+        triggered = any(k in payload for k in self._TRIGGER_FIELDS)
+        if not sends_conditions and not triggered:
+            offending = [k for k in self._UNMERGEABLE_ALONE if k in payload]
+            if offending:
+                raise ValueError(
+                    f"{' and '.join(offending)} cannot be updated on their own: the engine only "
+                    "rebuilds a pattern's conditions when includeTerms/regex/semanticPrompt is "
+                    "sent (alone they are silently ignored), and the wire GET returns display-"
+                    "only placeholders (includeTerms/excludeTerms always [], matchMode always "
+                    "'any'), so there is no stored value to merge them over. Pass "
+                    "conditions=[...] built from get(pattern_id).conditions instead, or send "
+                    "them alongside the trigger field they should be rebuilt with."
+                )
+        if triggered and not sends_conditions:
+            stored = self.get(pattern_id)
+            # The rebuild's detector kind follows the trigger field actually sent - back-filling
+            # the STORED kind 400s a kind change (regex= on a "contains" pattern) and silently
+            # corrupts the inverse (include_terms= on a regex pattern would write phrase
+            # conditions while keeping detectorKind "regex").
+            if "regex" in payload:
+                inferred_kind = "regex"
+            elif "semanticPrompt" in payload:
+                inferred_kind = "semantic"
+            else:
+                inferred_kind = "contains"
+            payload.setdefault("detectorKind", inferred_kind)
+            # matchTarget is the one field the wire reports faithfully - it rides along so the
+            # server-side full-replace rebuild keeps the stored target. NEVER includeTerms/
+            # excludeTerms/matchMode - see _UNMERGEABLE_ALONE's comment.
+            payload.setdefault("matchTarget", stored.match_target)
         data = self._client._request(
             "PUT",
             f"/agent-monitoring/patterns/{pattern_id}",
             base=self._client._api_root(),
-            json=fields,
+            json=payload,
+            # An idempotent merge server-side (same payload, same result) - but the read-
+            # merge-write above is not atomic, so keep the single-shot posture.
             retry=False,
         )
         return MonitorPattern(**data["pattern"])

agentx/monitor/rules.py

@@ -70,9 +70,22 @@ class MonitorRulesClient:
 
     def update(self, rule_id: str, **fields: Any) -> MonitorRule:
         """Sparse update. snake_case keys are mapped to the wire (``sample_rate`` ->
-        ``sampleRate``, ``action_config`` -> ``actionConfig``)."""
+        ``sampleRate``, ``action_config`` -> ``actionConfig``); an unrecognized snake_case
+        key raises instead of 200ing with the rule unchanged (the engine reads only camelCase
+        and silently keeps the stored value for keys it does not know)."""
         aliases = {"sample_rate": "sampleRate", "action_config": "actionConfig"}
-        payload = {aliases.get(k, k): v for k, v in fields.items()}
+        payload: Dict[str, Any] = {}
+        for key, value in fields.items():
+            wire_key = aliases.get(key, key)
+            if "_" in wire_key:
+                raise ValueError(
+                    f"Unknown rule field {key!r} - the engine reads camelCase keys and would "
+                    "silently ignore this (see MonitorRule for the field names)."
+                )
+            payload[wire_key] = value
+        # PUT /rules/:id is an idempotent full-body merge (same payload, same result), so the
+        # transport's default retry is safe - and skipping it just drops legitimate edits on a
+        # transient failure.
         data = self._request("PUT", f"/agent-monitoring/rules/{rule_id}", json=payload)
         return MonitorRule(data.get("rule", data))
 

agentx/monitor/scorer_groups.py

@@ -10,6 +10,7 @@ from typing import Any, Dict, List, Optional
 import requests
 
 from agentx.exceptions import AgentXError, AgentXAuthError, AgentXValidationError
+from agentx.monitor._transport import request_with_retries
 
 
 class AgentXScorerGroupsError(AgentXError):
@@ -49,7 +50,9 @@ class ScorerGroupsClient:
         self._workspace_id = workspace_id
         self._base = base_url.rstrip("/") + "/agent-monitoring/scorer-groups"
 
-    def _request(self, method: str, url: str, json: Optional[Dict[str, Any]] = None) -> Any:
+    def _request(
+        self, method: str, url: str, json: Optional[Dict[str, Any]] = None, retry: bool = True
+    ) -> Any:
         params = None
         if self._workspace_id:
             # Mirrors MonitorClient._workspace_params/_with_workspace: GETs (and DELETEs)
@@ -61,9 +64,12 @@ class ScorerGroupsClient:
                     json = {**json, "workspaceId": self._workspace_id}
             else:
                 params = {"workspaceId": self._workspace_id}
-        response = requests.request(
+        # retry=False for ANY non-idempotent write (creates, deletes) -
+        # MonitorClient._request's posture, via the shared monitor transport.
+        response = request_with_retries(
             method,
             url,
+            retry=retry,
             headers={"x-api-key": self._api_key, "content-type": "application/json"},
             json=json,
             params=params,
@@ -106,15 +112,33 @@ class ScorerGroupsClient:
             payload["description"] = description
         if online is not None:
             payload["online"] = online
-        return ScorerGroup(self._request("POST", self._base, json=payload)["scorerGroup"])
+        # Server-side create: a timeout + transport retry would create the group twice.
+        return ScorerGroup(
+            self._request("POST", self._base, json=payload, retry=False)["scorerGroup"]
+        )
 
     def update(self, group_id: str, **fields: Any) -> ScorerGroup:
-        """Sparse update - pass any of name/description/members/online (online=None detaches
-        live scoring)."""
+        """Sparse update - pass any of name/description/members/online. ``online`` itself may be
+        partial: ``online={"enabled": False}`` pauses live scoring, the engine merges the patch
+        over the stored profile. ``online=None`` detaches live scoring entirely. A partial
+        ``online=`` patch on a group with NO stored live profile is rejected by the engine
+        (400) - send the full profile the first time (the shape ``create`` documents)."""
+        # Same guard patterns.update/rules.update carry: the engine's schema strips keys it
+        # does not recognize, so a snake_case key would 200 with the group unchanged.
+        for key in fields:
+            if "_" in key:
+                first, *rest = key.split("_")
+                camel = first + "".join(part.capitalize() for part in rest)
+                raise ValueError(
+                    f"Unknown scorer group field {key!r} - the engine reads camelCase keys and "
+                    f"would silently ignore this; send {camel!r} instead."
+                )
         return ScorerGroup(self._request("PUT", f"{self._base}/{group_id}", json=fields)["scorerGroup"])
 
     def delete(self, group_id: str) -> None:
-        self._request("DELETE", f"{self._base}/{group_id}")
+        # retry=False: a lost response + transport retry would turn a successful delete
+        # into a spurious 404.
+        self._request("DELETE", f"{self._base}/{group_id}", retry=False)
 
     def ratings(self, group_id: str, window: str = "7d") -> Dict[str, Any]:
         """Live score history for a group - ``{"window", "points": [{ts, averageRating, count}]}``,

agentx/monitor/scorers.py

@@ -5,6 +5,7 @@ from typing import Any, Dict, List, Optional, Sequence
 
 import requests
 
+from agentx.monitor._transport import request_with_retries
 from agentx.util import api_base, get_headers
 from agentx.exceptions import AgentXError, AgentXAuthError, AgentXValidationError
 
@@ -52,7 +53,9 @@ class ScorersClient:
         # Captured once at construction (deep-dive round 3, bug #1).
         self._base_url = (base_url or api_base()).rstrip("/")
 
-    def _request(self, method: str, path: str, json: Any = None, params: Any = None) -> Any:
+    def _request(
+        self, method: str, path: str, json: Any = None, params: Any = None, retry: bool = True
+    ) -> Any:
         if self._workspace_id:
             # Mirrors MonitorClient._workspace_params/_with_workspace: GETs (and DELETEs)
             # carry workspaceId as a query param, write bodies carry it as a field.
@@ -63,9 +66,12 @@ class ScorersClient:
                     json = {**json, "workspaceId": self._workspace_id}
             elif not (params or {}).get("workspaceId"):
                 params = {**(params or {}), "workspaceId": self._workspace_id}
-        resp = requests.request(
+        # retry=False for ANY non-idempotent write (creates, deletes, dry-run executions) -
+        # MonitorClient._request's posture, via the shared monitor transport.
+        resp = request_with_retries(
             method,
             f"{self._base_url}/agent-monitoring{path}",
+            retry=retry,
             headers={**get_headers(self._api_key), "Content-Type": "application/json"},
             json=json,
             params=params,
@@ -147,7 +153,8 @@ class ScorersClient:
         ``None`` to skip; a score below ``alert_below`` raises a signal."""
         if language not in ("python", "javascript"):
             raise AgentXScorersError('language must be "python" or "javascript"')
-        return self._request("POST", "/custom-evaluators", json={
+        # Server-side create: a timeout + transport retry would deploy the scorer twice.
+        return self._request("POST", "/custom-evaluators", retry=False, json={
             "name": name,
             "kind": "code",
             "language": language,
@@ -173,7 +180,8 @@ class ScorersClient:
         agent_ids: Optional[Sequence[str]] = None,
     ) -> Dict[str, Any]:
         """Register an external scorer endpoint (POSTed the v2 payload per sampled trace)."""
-        return self._request("POST", "/custom-evaluators", json={
+        # Server-side create: a timeout + transport retry would register the scorer twice.
+        return self._request("POST", "/custom-evaluators", retry=False, json={
             "name": name,
             "url": url,
             "sampleRate": sample_rate,
@@ -191,7 +199,9 @@ class ScorersClient:
         return self._request("PUT", f"/custom-evaluators/{scorer_id}", json=wire)["evaluator"]
 
     def delete(self, scorer_id: str) -> None:
-        self._request("DELETE", f"/custom-evaluators/{scorer_id}")
+        # retry=False: a lost response + transport retry would turn a successful delete
+        # into a spurious 404.
+        self._request("DELETE", f"/custom-evaluators/{scorer_id}", retry=False)
 
     def events(self, scorer_id: str, window: str = "24h") -> List[Dict[str, Any]]:
         """The scorer's per-check history (score, matched, justification, trace ids)."""
@@ -201,7 +211,9 @@ class ScorersClient:
         """Execute a scorer against the built-in sample without persisting: pass either
         ``url=...`` (external) or ``kind="code", language=..., script=...`` (code)."""
         wire = {_SNAKE_TO_WIRE.get(k, k): v for k, v in payload.items()}
-        return self._request("POST", "/custom-evaluators/dry-run", json=wire)
+        # Executes real scorer work (and, for external, hits the user's endpoint) - a
+        # client-side timeout must not fire it twice.
+        return self._request("POST", "/custom-evaluators/dry-run", json=wire, retry=False)
 
 
 _SNAKE_TO_WIRE = {

agentx/resources/agent.py

@@ -1,14 +1,12 @@
 from typing import Optional, List
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, PrivateAttr, Field
 import requests
 import os
 import logging
-from dataclasses import dataclass
 from agentx.util import get_headers, api_base
 from .conversation import Conversation
 
 
-@dataclass
 class Agent(BaseModel):
     id: str = Field(alias="_id")
     name: str
@@ -16,16 +14,35 @@ class Agent(BaseModel):
     createdAt: Optional[str] = None
     updatedAt: Optional[str] = None
 
+
+    # Hosted credentials threaded from the constructing AgentX client. The module-level
+    # api_base()/get_headers() read only env vars, and the client deliberately stopped
+    # writing its constructor args into os.environ - without binding, a client created with
+    # api_key=/base_url= issued these calls unauthenticated against the default host.
+    _api_key: Optional[str] = PrivateAttr(default=None)
+    _base_url: Optional[str] = PrivateAttr(default=None)
+
+    def _bind(self, api_key: Optional[str], base_url: Optional[str]) -> "Agent":
+        self._api_key = api_key
+        self._base_url = base_url
+        return self
+
+    def _api_base(self) -> str:
+        return self._base_url or api_base()
+
+    def _headers(self):
+        return get_headers(self._api_key)
+
     def __init__(self, **data):
         super().__init__(**data)
 
     def new_conversation(self) -> Conversation:
-        url = f"{api_base()}/access/agents/{self.id}/conversations/new"
-        response = requests.post(url, headers=get_headers(), json={"type": "chat"})
+        url = f"{self._api_base()}/access/agents/{self.id}/conversations/new"
+        response = requests.post(url, headers=self._headers(), json={"type": "chat"})
         if response.status_code == 200:
             data = response.json()
             data["agent_id"] = self.id
-            return Conversation(**data)
+            return Conversation(**data)._bind(self._api_key, self._base_url)
         else:
             raise Exception(f"Failed to create conversation: {response.reason}")
 
@@ -37,8 +54,8 @@ class Agent(BaseModel):
         )
 
     def list_conversations(self) -> List[Conversation]:
-        url = f"{api_base()}/access/agents/{self.id}/conversations"
-        response = requests.get(url, headers=get_headers())
+        url = f"{self._api_base()}/access/agents/{self.id}/conversations"
+        response = requests.get(url, headers=self._headers())
         if response.status_code == 200:
             return [
                 Conversation(
@@ -49,7 +66,9 @@ class Agent(BaseModel):
                     agents=conv_res.get("bots"),
                     createdAt=conv_res.get("createdAt"),
                     updatedAt=conv_res.get("updatedAt"),
-                )
+                    # Bound to this agent's own credentials (threaded in via Agent._bind) so
+                    # the conversation's calls authenticate the same way this listing did.
+                )._bind(self._api_key, self._base_url)
                 for conv_res in response.json()
             ]
         else:

agentx/resources/conversation.py

@@ -1,7 +1,7 @@
 import json
 import requests
 from typing import Optional, List, Any, Iterator
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, PrivateAttr, Field
 from agentx.util import get_headers, api_base
 
 
@@ -42,28 +42,49 @@ class Conversation(BaseModel):
         populate_by_name = True
         extra = "ignore"
 
+
+    # Hosted credentials threaded from the constructing AgentX client. The module-level
+    # api_base()/get_headers() read only env vars, and the client deliberately stopped
+    # writing its constructor args into os.environ - without binding, a client created with
+    # api_key=/base_url= issued these calls unauthenticated against the default host.
+    _api_key: Optional[str] = PrivateAttr(default=None)
+    _base_url: Optional[str] = PrivateAttr(default=None)
+
+    def _bind(self, api_key: Optional[str], base_url: Optional[str]) -> "Conversation":
+        self._api_key = api_key
+        self._base_url = base_url
+        return self
+
+    def _api_base(self) -> str:
+        return self._base_url or api_base()
+
+    def _headers(self):
+        return get_headers(self._api_key)
+
     def __init__(self, **data):
         super().__init__(**data)
 
     def new_conversation(self) -> "Conversation":
-        url = f"{api_base()}/access/agents/{self.agent_id}/conversations/new"
+        url = f"{self._api_base()}/access/agents/{self.agent_id}/conversations/new"
         response = requests.post(
             url,
-            headers=get_headers(),
+            headers=self._headers(),
             json={"type": "chat"},
         )
         if response.status_code == 200:
             new_conv = response.json()
             new_conv["agent_id"] = self.agent_id
-            return Conversation(**new_conv)
+            # Bound to this conversation's own credentials - unbound, the sibling
+            # conversation fell back to env credentials against the default host.
+            return Conversation(**new_conv)._bind(self._api_key, self._base_url)
         else:
             raise Exception(
                 f"Failed to create new conversation: {response.status_code} - {response.reason}"
             )
 
     def list_messages(self) -> List[Message]:
-        url = f"{api_base()}/access/agents/{self.agent_id}/conversations/{self.id}"
-        response = requests.get(url, headers=get_headers())
+        url = f"{self._api_base()}/access/agents/{self.agent_id}/conversations/{self.id}"
+        response = requests.get(url, headers=self._headers())
         if response.status_code == 200:
             res = response.json()
             if res.get("messages"):
@@ -83,18 +104,18 @@ class Conversation(BaseModel):
             )
 
     def chat(self, message: str, context: Optional[int] = None):
-        url = f"{api_base()}/access/conversations/{self.id}/message"
+        url = f"{self._api_base()}/access/conversations/{self.id}/message"
         response = requests.post(
             url,
-            headers=get_headers(),
+            headers=self._headers(),
             json={"message": message, "context": context},
         )
         return response.json()
 
     def chat_stream(self, message: str, context: Optional[int] = None) -> Iterator[ChatResponse]:
-        url = f"{api_base()}/access/conversations/{self.id}/jsonmessagesse"
+        url = f"{self._api_base()}/access/conversations/{self.id}/jsonmessagesse"
         response = requests.post(
-            url, headers=get_headers(), json={"message": message, "context": context}
+            url, headers=self._headers(), json={"message": message, "context": context}
         )
         result = ""
         if response.status_code == 200:

agentx/resources/workforce.py

@@ -1,5 +1,5 @@
 from typing import Optional, List, Dict, Any, Iterator
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, PrivateAttr, Field
 import requests
 import os
 import json
@@ -46,19 +46,44 @@ class Workforce(BaseModel):
         populate_by_name = True
         extra = "ignore"
 
+
+    # Hosted credentials threaded from the constructing AgentX client. The module-level
+    # api_base()/get_headers() read only env vars, and the client deliberately stopped
+    # writing its constructor args into os.environ - without binding, a client created with
+    # api_key=/base_url= issued these calls unauthenticated against the default host.
+    _api_key: Optional[str] = PrivateAttr(default=None)
+    _base_url: Optional[str] = PrivateAttr(default=None)
+
+    def _bind(self, api_key: Optional[str], base_url: Optional[str]) -> "Workforce":
+        self._api_key = api_key
+        self._base_url = base_url
+        # The nested Agent objects issue their own calls (new_conversation,
+        # list_conversations) - left unbound they silently fall back to env credentials
+        # against the default host, the exact leak _bind exists to close.
+        self.manager._bind(api_key, base_url)
+        for agent in self.agents:
+            agent._bind(api_key, base_url)
+        return self
+
+    def _api_base(self) -> str:
+        return self._base_url or api_base()
+
+    def _headers(self):
+        return get_headers(self._api_key)
+
     def new_conversation(self) -> Conversation:
         """Create a new conversation for this workforce."""
-        url = f"{api_base()}/access/teams/{self.id}/conversations/new"
+        url = f"{self._api_base()}/access/teams/{self.id}/conversations/new"
         response = requests.post(
             url,
-            headers=get_headers(),
+            headers=self._headers(),
             json={"type": "chat"},
         )
         if response.status_code == 200:
             conv_data = response.json()
             # Set the agent_id to the manager's ID since this is a workforce conversation
             conv_data["agent_id"] = self.manager.id
-            return Conversation(**conv_data)
+            return Conversation(**conv_data)._bind(self._api_key, self._base_url)
         else:
             raise Exception(
                 f"Failed to create new conversation: {response.status_code} - {response.reason}"
@@ -66,14 +91,14 @@ class Workforce(BaseModel):
 
     def list_conversations(self) -> List[Conversation]:
         """List all conversations for this workforce."""
-        url = f"{api_base()}/access/teams/{self.id}/conversations"
-        response = requests.get(url, headers=get_headers())
+        url = f"{self._api_base()}/access/teams/{self.id}/conversations"
+        response = requests.get(url, headers=self._headers())
         if response.status_code == 200:
             conversations = []
             for conv_data in response.json():
                 # Set the agent_id to the manager's ID since this is a workforce conversation
                 conv_data["agent_id"] = self.manager.id
-                conversations.append(Conversation(**conv_data))
+                conversations.append(Conversation(**conv_data)._bind(self._api_key, self._base_url))
             return conversations
         else:
             raise Exception(
@@ -85,10 +110,10 @@ class Workforce(BaseModel):
     ) -> Iterator[ChatResponse]:
         """Send a message to a team conversation and stream the response."""
         url = (
-            f"{api_base()}/access/teams/conversations/{conversation_id}/jsonmessagesse"
+            f"{self._api_base()}/access/teams/conversations/{conversation_id}/jsonmessagesse"
         )
         response = requests.post(
-            url, headers=get_headers(), json={"message": message, "context": context}
+            url, headers=self._headers(), json={"message": message, "context": context}
         )
         result = ""
         if response.status_code == 200:

agentx/tracing/tracer.py

@@ -931,9 +931,11 @@ class Tracer:
         Deliberately NOT a retrieval: retrieval spans feed the RAG judges' ``{context}``
         (knowledge grounding), while memory is recalled state - see the engine's spanKind.ts.
 
-        With no active span the record is DROPPED (with a debug log), not queued: the only
-        pending queue rides the next trace's ``retrieval_steps``, and memory content must
-        never reach the engine's retrieval-context extraction for RAG judges. Wrap the call
+        With no active span the record is DROPPED (warns once per process, then logs at
+        debug), not queued. There are two pending queues (tool calls -> ``tool_calls``,
+        retrievals -> ``retrieval_steps``) and neither fits: ``retrieval_steps`` feeds the
+        engine's RAG ``{context}`` extraction, which recalled state must never reach, and no
+        memory-shaped queue has been built yet. Wrap the call
         in ``tracer.trace()`` to keep it - or, on a worker thread, wrap the worker body in
         ``tracer.use_span(span)`` - a bare thread starts with an empty span stack.
         (``record_tool_call``/``record_retrieval`` queue instead - see their docstrings.)
@@ -980,7 +982,7 @@ class Tracer:
             with tracer.trace_memory("user prefs", operation="read", query=user_id) as m:
                 m.output = memory.search(user_id, question)
 
-        With no active span the record is DROPPED (with a debug log), not queued - see
+        With no active span the record is DROPPED (warns once per process, then logs at debug), not queued - see
         :meth:`record_memory`. An exception escaping the block records the operation as
         failed (error set, output ``ERROR: ...``) and then propagates unchanged - same
         posture as :meth:`trace_tool_call`.

agentx/util.py

@@ -1,6 +1,8 @@
 import os
 from typing import Optional
 
+from agentx.exceptions import AgentXAuthError
+
 _DEFAULT_API_BASE = "https://api.agentx.so/api/v1"
 
 _EVALUATIONS_SUFFIX = "/custom-agent-evaluations"
@@ -26,4 +28,10 @@ def api_base() -> str:
 
 
 def get_headers(api_key: Optional[str] = None):
-    return {"accept": "*/*", "x-api-key": api_key or os.getenv("AGENTX_API_KEY")}
+    key = api_key or os.getenv("AGENTX_API_KEY")
+    if not key:
+        # A None header serializes as the literal string "None" (or drops), turning a config
+        # mistake into an opaque 401 from the server - fail loud at the call site instead,
+        # with the SDK's canonical auth error so `except agentx.AgentXAuthError` catches it.
+        raise AgentXAuthError("No API key: pass api_key= or set AGENTX_API_KEY")
+    return {"accept": "*/*", "x-api-key": key}

agentx/version.py

@@ -1,7 +1,7 @@
-VERSION = "0.8.24"
+VERSION = "0.8.26"
 
 # The AgentX-trace-eval release this SDK version is tested against - what `agentx-trace-eval`
 # installs and converges to (see agentx/cli.py). Bump together with VERSION when releasing, so
 # every published SDK names a known-good engine+dashboard pair. Users can override with
 # AGENTX_TRACE_EVAL_VERSION=<tag|latest>.
-ENGINE_VERSION = "v0.3.26"
+ENGINE_VERSION = "v0.3.29"

{agentx_python-0.8.24.dist-info → agentx_python-0.8.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentx-python
-Version: 0.8.24
+Version: 0.8.26
 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
@@ -23,6 +23,8 @@ Provides-Extra: openai-agents
 Requires-Dist: openai-agents>=0.0.3; extra == "openai-agents"
 Provides-Extra: openai
 Requires-Dist: openai>=1.0.0; extra == "openai"
+Provides-Extra: nvidia-nim
+Requires-Dist: openai>=1.0.0; extra == "nvidia-nim"
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.25.0; extra == "anthropic"
 Provides-Extra: google-adk
@@ -108,7 +110,9 @@ Also see [SDK Developer Docs](https://developers.agentx.so), [API Reference Docs
 pip install --upgrade agentx-python
 ```
 
-Requires Python 3.9 or newer.
+Requires Python 3.9 or newer for the core SDK. Some integration extras have higher floors set
+by their upstream packages - `[crewai]`, `[autogen]`, and `[databricks]` need Python 3.10+ (`[all]`
+therefore does too); the core tracer and every REST surface stay 3.9-compatible.
 
 #### Run the self-host governance suite locally
 
@@ -248,6 +252,7 @@ extra:
 | CrewAI                | `pip install "agentx-python[crewai]"`        | `AgentXCrewObserver`      |
 | OpenAI Agents SDK     | `pip install "agentx-python[openai-agents]"` | `AgentXTracingProcessor`  |
 | OpenAI (raw client)   | `pip install "agentx-python[openai]"`        | `patch_openai_client`     |
+| NVIDIA NIM            | `pip install "agentx-python[nvidia-nim]"`    | `patch_nim_client`        |
 | Anthropic             | `pip install "agentx-python[anthropic]"`     | `patch_anthropic_client`  |
 | Google ADK            | `pip install "agentx-python[google-adk]"`    | `AgentXADKPlugin`         |
 | Google GenAI (Gemini) | `pip install "agentx-python[google-genai]"`  | `patch_genai_client`      |

{agentx_python-0.8.24.dist-info → agentx_python-0.8.26.dist-info}/RECORD

@@ -1,5 +1,5 @@
 agentx/__init__.py,sha256=oIxNK1s1Gv7S5gKzhX0NC571TBvinzfn-OWevLMME_g,902
-agentx/agentx.py,sha256=2AzrlJsYX6qyzMh0sxNICvuAs9XrmX9floYbYqKrFeQ,11589
+agentx/agentx.py,sha256=IgFIQAHJoo-FyqMCGY6RdRMmHAnjtBXKTcXWlyDkeE8,12040
 agentx/cli.py,sha256=yawLQLSeZ7KIl7ukgmly-lrYbx9GgKcaI9M4xamiMPw,10468
 agentx/exceptions.py,sha256=jATpl8mdgdBpRPOLXu8ltdjF6s_V0a5mWdW0K5mDg68,2115
 agentx/export.py,sha256=nvFRn_d-9W_cHCEsh6rwOrYzVMJosfw493DG8Gi2Ca8,4309
@@ -9,8 +9,8 @@ agentx/projects.py,sha256=5s8_ib5HV5kTlPCCm7VsbSYsPP9JaARsA8VjYNR7m6o,2584
 agentx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 agentx/testing.py,sha256=0shZEid_vhJgBegpO_loUq6APYDxQrUgD3jvcRdIDV8,7372
 agentx/traces.py,sha256=Jh07n3GLS1SGRsDoLDTUaAbuMEdvjqxCCMA9gUcSZ0M,2331
-agentx/util.py,sha256=i2WYeKIjAUA5bIsw-3kgrTt_0iGl1mINystllwRbF_4,1036
-agentx/version.py,sha256=4gGOBy15J6mct2czcxkwQDA2ZAqN7_-mpU1da7rD2yw,366
+agentx/util.py,sha256=ivCuFQ5AGUw9fR9fJy5HrSp3lLwwngsDwppnvyZpq9E,1471
+agentx/version.py,sha256=mHuhKZSPSp8Xp5Pq7q93wgdcMtBUM_OBt-nWG4Qoh6g,366
 agentx/evaluations/__init__.py,sha256=Erv7RGFlRxGTG4rVb2uHhCqLLEX_iAWKqkZKzK6CumE,262
 agentx/evaluations/_term.py,sha256=WFpiNzdgDBeJJ-Gg-6X7TwwxllobuE4OqFUTuDQvS3Y,2529
 agentx/evaluations/client.py,sha256=7c35tS8zM3fuvFfVDQk5etTTEFiIykmPjuJxkuFyFTY,38013
@@ -27,11 +27,11 @@ agentx/evaluations/adapters/__init__.py,sha256=fK8Hx75usbiY03XUSmnLnSrwBXip2CQs2
 agentx/evaluations/adapters/http_endpoint.py,sha256=-Gika9lBcXjtbnyB-uNR6nYEVJhWEPtDazi9ixLvJtg,2059
 agentx/evaluations/adapters/precomputed.py,sha256=vxnQELmpiU2NkQATfiVjG7v1ZmmkrEA70Y11ijfYtHw,1208
 agentx/evaluations/adapters/raw.py,sha256=FkDq_mdf21-xt5EHnGyIGcS6VZxkEkFcmM9VTd-T5sA,1130
-agentx/integrations/__init__.py,sha256=W-EcQhHE01-SGPeKTB2AgfvUyRzNP4BqUMMtP2qQ4Q0,647
+agentx/integrations/__init__.py,sha256=p-YHLIudYxQj1bBj77NiVPsP0VQHemX5E59phkI3Y-Q,711
 agentx/integrations/_traced_call.py,sha256=OuFmSLw5vjI54gpdte7-zOt7gld7faQmvhuoh_3OPlo,6861
 agentx/integrations/anthropic.py,sha256=z6o9cC9rBzxxbF1UBiMr-kjEgDUO-BCuPOFoqGN3qF4,10451
 agentx/integrations/autogen.py,sha256=V1kvTjxQqOG9KsYd4dztaRYH7zTknW0_fqzKjIQG5dk,9507
-agentx/integrations/crewai.py,sha256=7YZhOGeztIg4F_5gGxUFHYprKCg7rJZFKHHcPcMG5ZM,14170
+agentx/integrations/crewai.py,sha256=SCObRsrS40P8jOGoI_T5oW4IYuoBW5WjBNuc7zUBU70,14346
 agentx/integrations/databricks.py,sha256=vKXnur-LWMTzctFuIKte2N826sydXVlpi1qFXo2dfio,18044
 agentx/integrations/google_adk.py,sha256=AHJFpt8ZKHuURqKQ9xVVvFqIm16R4bfRSJtIuWuL110,19213
 agentx/integrations/google_genai.py,sha256=2patIdgyjEEW70FLP7ng4hcnFY-p0a1jPi1Pof28KBo,13272
@@ -39,36 +39,38 @@ agentx/integrations/langchain.py,sha256=YDeEFT2irhoEvydwt3QjbmTpk_AZZbYPS9euOR18
 agentx/integrations/litellm.py,sha256=eW8iCaNq0feRbZma8iOvmJ28WiAO7ZaRmlpPjHAtcvo,7072
 agentx/integrations/llamaindex.py,sha256=ruzMiC2TC3Xhub4xoXKPHjsvzV1sQ3QqhjkAdMxUUi4,18001
 agentx/integrations/moveworks.py,sha256=IyBswLE5LwMSp1VbIvG5izYV5BvXmv4atZelnrDn8SE,25670
-agentx/integrations/openai.py,sha256=1KLs-hJaeW2emHPwNkmC3zcGksL3zd87uWbcLGRW704,6644
+agentx/integrations/nvidia_nim.py,sha256=bvS6ebEnQZT1DVlIjQQ2RKLI4uPPTdlMKINgDwj0Z-o,2961
+agentx/integrations/openai.py,sha256=edJL-HXTO7w-vvIZGQChMu0AnPCY5z0duplIi8z2gXE,6936
 agentx/integrations/openai_agents.py,sha256=KSOQ55eRPFxxkqm7p4Dsz6HcJ_9uUEwlyywPI8dwbvY,14852
-agentx/monitor/__init__.py,sha256=XqK1YV9FPn79gikbNx3_8MVY4czJJ8Q7eBxZzvjrhpw,1366
+agentx/monitor/__init__.py,sha256=Rkk-Xv1ymXwDFbx8fetmcOzXfSU1bvsazI_-x5Ati5g,1715
+agentx/monitor/_transport.py,sha256=ge0pmdvFdUtCJRkTLvAgjuTQVA8YOCYGQNoyRuselRk,2077
 agentx/monitor/agents.py,sha256=KhsHVhkqa6V0e0lPcuo04fh44_qSaJOaGcD6U6qXSFo,1622
-agentx/monitor/client.py,sha256=7ZcGBs3XTLNMEwXrQ7QE2zP8r1G4OZvZ2blQ-zi9cj0,27109
-agentx/monitor/improvement_groups.py,sha256=RlNHuDEfy9Cb9ZOnvau5zdB-YFHiqJsf_DI35iUjr3A,5505
-agentx/monitor/judge_scorers.py,sha256=ZailnmPJz6SxvyHBMUdvuqRjIX_TgpJKtIzulS8Zu_4,19868
+agentx/monitor/client.py,sha256=JoKp3AmFtQ4UDOsNH5nWEkTjvQtBrrihObGaPVMtBYo,27270
+agentx/monitor/improvement_groups.py,sha256=MrXexaBLPNzZHrqZjiCPfmwa-DSr-RHuFdP73SKrMJM,6143
+agentx/monitor/judge_scorers.py,sha256=Xyoafo9ljeq5RpLe5HxvsL0Y0FebFQ-2CxYz8-E1Wio,21025
 agentx/monitor/models.py,sha256=mNBQDXdVthGYHUyEeRgpFdKVOC9uMtdUgBlLfep1E14,9298
 agentx/monitor/online_evaluators.py,sha256=YWnsBmlIbYvj4LCaX4guwx4HS5y3oEzCQfo6ae9VH_w,8693
-agentx/monitor/patterns.py,sha256=AEYv34X4xWCUrC0C0WV470PoSz1olvDOZ6vqGeAu79g,5948
+agentx/monitor/patterns.py,sha256=mHYqsigHXKkgUKYjHjj-ENXjqJZh9xpe73jdFgtsXcM,11758
 agentx/monitor/profile.py,sha256=2ZT0HwTm47lcd_KKpAMfi5SU4vKQLj4C1IRTd5SELOY,3210
 agentx/monitor/review_queue.py,sha256=i6Dp8ezTkGva0DBRhLOLgBqFychVFdig73jIpS6wo_g,4104
-agentx/monitor/rules.py,sha256=2cBLe4_DN8ck37VYxFgs1azkRFBwi0bGTl5crRAJJRM,3366
-agentx/monitor/scorer_groups.py,sha256=OS-gBnLURAc3zMcdlAnGM3mrBcp6vxoDDsua11QN7LQ,5568
-agentx/monitor/scorers.py,sha256=poYfVl6vsuwSSfDifS222pR6LyER3UudznAJ3jX8GNQ,9649
+agentx/monitor/rules.py,sha256=u5ezzMt8-YQHwH-XJLg4YAAox88iO0VTaC6R4ZdcGUw,4132
+agentx/monitor/scorer_groups.py,sha256=uEtRvGpn2ho3O4AhkHyt_u1h0G5MS1fbUJCk_Pn4T4U,7019
+agentx/monitor/scorers.py,sha256=NCag_CwUKOiDsmriKqKsoEhy6DBS7H0AVW5w8Ma7Nps,10432
 agentx/monitor/sessions.py,sha256=bJOp-yBgnKczq2J8jsPSrstlViOkdGGN7ixH3oOYb7Q,2472
 agentx/monitor/signals.py,sha256=Ld11lW2lbg8NHBUHdgoY6iwCvJDK-eg4ge4qQ9y7nGY,1432
 agentx/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-agentx/resources/agent.py,sha256=ZKpxDYzJbKgOX4-W86U__b4gko7XlbwB4q6L8Az9uo0,2011
-agentx/resources/conversation.py,sha256=94pOdM6Pmj67RhikZVBNGkT3V-WKK_ZAD7s27p5-N0Y,4463
-agentx/resources/workforce.py,sha256=lfGVkoV9lcOp-lZScjTvwRarJMkhzfMfLm4syJDujGc,4168
+agentx/resources/agent.py,sha256=1WH6v6uMueqOI0TSFPTWQ_Ql3SRcq-uB7MkduPJC2qs,3033
+agentx/resources/conversation.py,sha256=fPqvsmKW7VsHt3RDA__70I_FL6Imwm_ssmU3ObTVhec,5496
+agentx/resources/workforce.py,sha256=cB9baw2ilf7Grw_xz1W0T3LENxo8HhrOjDwwppOrAv8,5424
 agentx/tracing/__init__.py,sha256=l2mIRILE-wWrCD0fekgrIOQUEvtDObzdrkgpQUtXroU,408
 agentx/tracing/ci_types.py,sha256=b-W2LowRhNBVUdaoMPgd4bnKQy9AxhfiikftRwGPAqU,1778
 agentx/tracing/eval_scope.py,sha256=ElMbPxpqpQBVuaUnHNlw9RIQu71oyOpd0yR55bDH8eI,2144
 agentx/tracing/framework_detect.py,sha256=uV4O7Th-4_2UkdooAyaWCOIA0jwLJbblFQ_ucFDjeJM,2638
 agentx/tracing/ingest_client.py,sha256=teukTPckFWPg5RhpbGbVDBejBzPIPXUO3_DJcuVh2uc,22660
-agentx/tracing/tracer.py,sha256=P1vixRBhkFE-XhDumTFHHc-TW3R4PeZ7MeCqKcA6mSE,68368
-agentx_python-0.8.24.dist-info/licenses/LICENSE,sha256=gZVsM-nLsE8vlaY6NXXsVoo6IlCClxkToAWmhgT3y_s,10762
-agentx_python-0.8.24.dist-info/METADATA,sha256=9d42oTt7FlCeNdYO3vvwkz068omkH8ZmOUDoYI-tdM8,22561
-agentx_python-0.8.24.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-agentx_python-0.8.24.dist-info/entry_points.txt,sha256=rQqF1JTY3T1yfviBU1r8PU-5mBdfOk6P4bZ1L4BskIM,172
-agentx_python-0.8.24.dist-info/top_level.txt,sha256=s-q-HB9Gb_QdrZNacSeQyF_c25gQooMy7DlxzgLOHPk,7
-agentx_python-0.8.24.dist-info/RECORD,,
+agentx/tracing/tracer.py,sha256=NS0bs5HbDDK3l0Z95KVKV3xCNJT7LINS0EoPFM-wzIk,68543
+agentx_python-0.8.26.dist-info/licenses/LICENSE,sha256=gZVsM-nLsE8vlaY6NXXsVoo6IlCClxkToAWmhgT3y_s,10762
+agentx_python-0.8.26.dist-info/METADATA,sha256=JH0SY8e_dBGzmK92xd_Cas62qpPweH0BoBLbDmE7xPA,22986
+agentx_python-0.8.26.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+agentx_python-0.8.26.dist-info/entry_points.txt,sha256=rQqF1JTY3T1yfviBU1r8PU-5mBdfOk6P4bZ1L4BskIM,172
+agentx_python-0.8.26.dist-info/top_level.txt,sha256=s-q-HB9Gb_QdrZNacSeQyF_c25gQooMy7DlxzgLOHPk,7
+agentx_python-0.8.26.dist-info/RECORD,,