agentx-python 0.6.34__py3-none-any.whl → 0.6.36__py3-none-any.whl

agentx/agentx.py

@@ -20,10 +20,12 @@ class AgentX:
         if self.api_key and not os.getenv("AGENTX_API_KEY"):
             os.environ["AGENTX_API_KEY"] = self.api_key
 
-        # base_url overrides AGENTX_API_BASE_URL env var (and the SDK default)
+        # base_url overrides AGENTX_API_BASE_URL env var (and the SDK default). It is
+        # deliberately NOT written back into os.environ: the constructor used to do that, which
+        # made the last-constructed client silently re-point every other client in the process
+        # (deep-dive round 3, bug #1). Each sub-client below receives this value explicitly and
+        # captures it at construction instead.
         self.base_url = base_url or os.getenv("AGENTX_API_BASE_URL")
-        if self.base_url:
-            os.environ["AGENTX_API_BASE_URL"] = self.base_url
 
         self.workspace_id = workspace_id or os.getenv("AGENTX_WORKSPACE_ID")
 
@@ -58,29 +60,29 @@ class AgentX:
 
         # Report real, after-the-fact outcomes ("the ticket got reopened") against traces - the
         # ground truth behind the dashboard's Judge Calibration card. Self-host only.
-        self.outcomes = OutcomesClient(api_key=self.api_key)
+        self.outcomes = OutcomesClient(api_key=self.api_key, base_url=self.base_url)
 
         from agentx.projects import ProjectsClient
 
         # Project CRUD (self-host): isolated tenants with their own API keys (P1.1).
-        self.projects = ProjectsClient(api_key=self.api_key)
+        self.projects = ProjectsClient(api_key=self.api_key, base_url=self.base_url)
 
         from agentx.traces import TracesClient
 
         # The read side of tracing: trace-by-id detail and paginated listing (P1.2).
-        self.traces = TracesClient(api_key=self.api_key)
+        self.traces = TracesClient(api_key=self.api_key, base_url=self.base_url)
 
         from agentx.export import ExportClient
 
         # Bulk NDJSON egress for backup/migration (P2.1): manifest, per-entity streaming, and
         # directory dumps. Self-host only.
-        self.export = ExportClient(api_key=self.api_key)
+        self.export = ExportClient(api_key=self.api_key, base_url=self.base_url)
 
         from agentx.feedback import FeedbackClient
 
         # Forward end-user votes ("up"/"down") on traced responses - a "down" raises a signal
         # directly, and every vote feeds Judge Calibration alongside outcomes. Self-host only.
-        self.feedback = FeedbackClient(api_key=self.api_key)
+        self.feedback = FeedbackClient(api_key=self.api_key, base_url=self.base_url)
 
         _ingest_client = IngestClient(
             api_key=self.api_key,
@@ -92,13 +94,23 @@ class AgentX:
 
     @classmethod
     def from_env(cls) -> "AgentX":
-        """Create an AgentX client using AGENTX_API_KEY (and optionally AGENTX_API_BASE_URL) from the environment."""
-        return cls()
+        """Create an AgentX client from the environment: AGENTX_API_KEY plus, for the base URL,
+        the first of AGENTX_API_BASE_URL / AGENTX_SELFHOST_BASE_URL / BASE_URL that is set.
+        The fallbacks match the conventions the self-host samples and .env files already use,
+        so from_env works wherever an explicit AgentX(base_url=...) would."""
+        import os
+
+        base_url = (
+            os.getenv("AGENTX_API_BASE_URL")
+            or os.getenv("AGENTX_SELFHOST_BASE_URL")
+            or os.getenv("BASE_URL")
+        )
+        return cls(base_url=base_url) if base_url else cls()
 
     def get_agent(self, id: str) -> Agent:
-        url = f"{api_base()}/access/agents/{id}"
+        url = f"{self.base_url or api_base()}/access/agents/{id}"
         # Make a GET request to the AgentX API
-        response = requests.get(url, headers=get_headers())
+        response = requests.get(url, headers=get_headers(self.api_key))
         # Check if response was successful
         if response.status_code == 200:
             return Agent(**response.json())
@@ -106,9 +118,9 @@ class AgentX:
             raise Exception(f"Failed to retrieve agent: {response.reason}")
 
     def list_agents(self) -> List[Agent]:
-        url = f"{api_base()}/access/agents"
+        url = f"{self.base_url or api_base()}/access/agents"
         # Make a GET request to the AgentX API
-        response = requests.get(url, headers=get_headers())
+        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()]
@@ -146,7 +158,7 @@ class AgentX:
         """
         from agentx.exceptions import AgentXAPIError, AgentXAuthError, AgentXConnectionError
 
-        base = api_base()
+        base = (self.base_url or api_base()).rstrip("/")
         # /monitor/patterns: the cheapest key-authenticated endpoint that exists on both the
         # hosted API and the self-host engine's SDK-facing router.
         url = f"{base}/monitor/patterns"
@@ -173,8 +185,8 @@ class AgentX:
 
     def get_profile(self):
         """Get the current user's profile information."""
-        url = f"{api_base()}/access/getProfile"
-        response = requests.get(url, headers=get_headers())
+        url = f"{self.base_url or api_base()}/access/getProfile"
+        response = requests.get(url, headers=get_headers(self.api_key))
         if response.status_code == 200:
             return response.json()
         else:

agentx/evaluations/client.py

@@ -59,6 +59,15 @@ class AgentXValidationError(AgentXEvaluationsError):
     pass
 
 
+def _resolve_scorer_id(scorer_id: Optional[str], evaluation_settings_id: Optional[str]) -> Optional[str]:
+    """One grader, two spellings: ``scorer_id`` is the post-consolidation name for what the wire
+    still calls ``evaluationSettingsId`` (the ids are identical by design). Both kwargs are
+    accepted everywhere a run picks its grader; passing both with different values is a bug."""
+    if scorer_id and evaluation_settings_id and scorer_id != evaluation_settings_id:
+        raise ValueError("Pass either scorer_id or evaluation_settings_id (they are the same id), not two different ids")
+    return scorer_id or evaluation_settings_id
+
+
 class EvaluationsClient:
     def __init__(
         self,
@@ -100,11 +109,21 @@ class EvaluationsClient:
         from agentx.evaluations.prompts import PromptClient
 
         self.datasets = DatasetClient(self)
-        self.settings = EvaluationSettingsClient(self)
+        # Legacy view of an LLM Judge Scorer's offline profile - constructed lazily so its
+        # DeprecationWarning fires on first USE, not for every client that never touches it.
+        self._settings: "EvaluationSettingsClient | None" = None
         self.prompts = PromptClient(self)
         from agentx.evaluations.tool_schemas import ToolSchemaClient
         self.tool_schemas = ToolSchemaClient(self)
 
+    @property
+    def settings(self) -> "EvaluationSettingsClient":
+        if self._settings is None:
+            from agentx.evaluations.evaluation_settings import EvaluationSettingsClient
+
+            self._settings = EvaluationSettingsClient(self)
+        return self._settings
+
     # ------------------------------------------------------------------
     # Low-level HTTP
     # ------------------------------------------------------------------
@@ -275,10 +294,16 @@ class EvaluationsClient:
         dataset_id: str,
         subject: EvaluationSubject,
         python_version: Optional[str] = None,
+        scorer_id: Optional[str] = None,
         evaluation_settings_id: Optional[str] = None,
     ) -> EvaluationRun:
+        """``scorer_id`` names the LLM Judge Scorer grading this run (its id doubles as the
+        wire's ``evaluationSettingsId``). ``evaluation_settings_id`` is the pre-consolidation
+        alias and keeps working."""
         from agentx.version import VERSION
 
+        grader_id = _resolve_scorer_id(scorer_id, evaluation_settings_id)
+
         payload = {
             "datasetId": dataset_id,
             "evaluationSubject": subject.model_dump(by_alias=True, exclude_none=True),
@@ -290,8 +315,8 @@ class EvaluationsClient:
                 "pythonVersion": python_version or _python_version(),
             },
         }
-        if evaluation_settings_id:
-            payload["evaluationSettingsId"] = evaluation_settings_id
+        if grader_id:
+            payload["evaluationSettingsId"] = grader_id
         data = self._request("POST", "/runs", json=self._with_workspace(payload))
         return EvaluationRun(**data)
 

agentx/evaluations/datasets.py

@@ -290,6 +290,7 @@ class DatasetClient:
         rouge_score: bool = False,
         similarity_model: Optional[str] = None,
         sovereignty_models: Optional[List[str]] = None,
+        code_scorers: Optional[List[Dict[str, Any]]] = None,
     ) -> DatasetBuilder:
         return DatasetBuilder(
             self._client,
@@ -307,6 +308,9 @@ class DatasetClient:
             rouge_score=rouge_score,
             similarity_model=similarity_model,
             sovereignty_models=sovereignty_models,
+            # Was documented (evaluation/code-scorers.mdx) but not forwarded - DatasetBuilder
+            # itself always accepted it. Fixed with the judge-scorer unification.
+            code_scorers=code_scorers,
         )
 
     def from_csv(self, path: str, name: str, **kwargs) -> DatasetBuilder:

agentx/evaluations/evaluation_settings.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+import warnings
 from typing import Any, Dict, List, Optional, TYPE_CHECKING
 
 from agentx.evaluations.models import EvaluationSettings
@@ -81,10 +82,25 @@ class EvaluationSettingsBuilder:
 
 
 class EvaluationSettingsClient:
-    """Thin wrapper surfaced as client.evaluations.settings."""
+    """Thin wrapper surfaced as ``client.evaluations.settings``.
+
+    Note: an evaluation-settings record is the judge rubric + OFFLINE profile of an
+    **LLM Judge Scorer** - the unified entity at ``client.monitor.judge_scorers``, which also
+    carries the optional online (live-traffic) profile. This client keeps working unchanged;
+    prefer ``judge_scorers`` for new code so both profiles live in one place -
+    ``client.monitor.judge_scorers.builder(...)`` has the same snake_case ergonomics as the
+    builder below, plus tool_context, thresholds, and the live profile in one call."""
 
     def __init__(self, client: "EvaluationsClient"):
         self._client = client
+        # Soft deprecation: hidden by default (DeprecationWarning), visible under -W or pytest.
+        warnings.warn(
+            "client.evaluations.settings is the legacy view of an LLM Judge Scorer's offline "
+            "profile; prefer client.monitor.judge_scorers, which manages the judge rubric, "
+            "offline profile, and online (live-traffic) profile as one entity.",
+            DeprecationWarning,
+            stacklevel=3,
+        )
 
     def builder(
         self,

agentx/evaluations/models.py

@@ -94,7 +94,7 @@ class Dataset(BaseModel):
 
 class EvaluationSettings(BaseModel):
     """A standalone, reusable grading config - no dataset/questions attached.
-    Created via ``client.evaluations.settings.builder(...).publish()`` and run
+    Created via ``client.monitor.judge_scorers.builder(...).publish()`` (or the legacy ``client.evaluations.settings.builder``) and run
     against any dataset by passing its id as ``evaluation_settings_id`` to
     ``client.evaluations.run(...)``."""
 

agentx/evaluations/runner.py

@@ -421,10 +421,15 @@ class EvaluationsRunner:
     def __init__(self, client: EvaluationsClient):
         self._client = client
         self.datasets = client.datasets
-        self.settings = client.settings
         self.prompts = client.prompts
         self.tool_schemas = client.tool_schemas
 
+    @property
+    def settings(self):
+        # Deferred: touching client.settings eagerly here would fire its legacy-surface
+        # DeprecationWarning for every runner, used or not.
+        return self._client.settings
+
     def list_models(self, provider: Optional[str] = None) -> List[ModelInfo]:
         """List the LLM models AgentX supports - the same set selectable for
         the Sovereignty & Portability Index. Pass ``provider`` (e.g. "Google")
@@ -482,24 +487,24 @@ class EvaluationsRunner:
         self,
         dataset_id: str,
         subject: Union[Dict[str, Any], EvaluationSubject],
+        scorer_id: Optional[str] = None,
         evaluation_settings_id: Optional[str] = None,
     ) -> EvaluationRunContext:
-        """Start a run of ``dataset_id`` against ``subject``. Pass
-        ``evaluation_settings_id`` to grade against a standalone, reusable
-        config (created via ``client.evaluations.settings.builder(...)``)
-        instead of the dataset's own default config."""
+        """Start a run of ``dataset_id`` against ``subject``. Pass ``scorer_id`` (an LLM Judge
+        Scorer's id, e.g. from ``client.monitor.judge_scorers``) to grade with a specific
+        scorer instead of the dataset's default. ``evaluation_settings_id`` is the
+        pre-consolidation alias for the same id and keeps working."""
+        from agentx.evaluations.client import _resolve_scorer_id
+
         if isinstance(subject, dict):
             subject = EvaluationSubject(**subject)
 
+        grader_id = _resolve_scorer_id(scorer_id, evaluation_settings_id)
         dataset = self._client.get_dataset(dataset_id)
         evaluation_settings = (
-            self._client.get_evaluation_settings(evaluation_settings_id)
-            if evaluation_settings_id
-            else None
-        )
-        run = self._client.init_run(
-            dataset_id, subject, evaluation_settings_id=evaluation_settings_id
+            self._client.get_evaluation_settings(grader_id) if grader_id else None
         )
+        run = self._client.init_run(dataset_id, subject, scorer_id=grader_id)
         logger.info(
             "Started evaluation run %s on dataset %s (%d case(s), %d repetition(s))",
             run.run_id,

agentx/export.py

@@ -36,13 +36,15 @@ class ExportClient:
     (``pg_dump`` / SQLite file copy). There is deliberately no blind row-import endpoint.
     """
 
-    def __init__(self, api_key: Optional[str] = None):
+    def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None):
         self._api_key = api_key
+        # Captured once at construction (deep-dive round 3, bug #1).
+        self._base_url = (base_url or api_base()).rstrip("/")
 
     def manifest(self) -> List[Dict[str, Any]]:
         """The exportable entities with live row counts: ``[{entity, rows, path}, ...]``."""
         resp = requests.get(
-            f"{api_base()}/export", headers=get_headers(self._api_key), timeout=30
+            f"{self._base_url}/export", headers=get_headers(self._api_key), timeout=30
         )
         if resp.status_code >= 400:
             raise AgentXExportError(f"Export manifest failed ({resp.status_code}): {resp.text[:200]}")
@@ -54,7 +56,7 @@ class ExportClient:
         timestamp column, e.g. ``createdAt`` for traces, ``lastSeenAt`` for signals)."""
         params = {"since": since} if since else None
         resp = requests.get(
-            f"{api_base()}/export/{entity}",
+            f"{self._base_url}/export/{entity}",
             headers=get_headers(self._api_key),
             params=params,
             stream=True,

agentx/feedback.py

@@ -26,8 +26,10 @@ class FeedbackClient:
     reopened", reported by a workflow); feedback is a human vote with up/down semantics.
     """
 
-    def __init__(self, api_key: Optional[str] = None):
+    def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None):
         self._api_key = api_key
+        # Captured once at construction (deep-dive round 3, bug #1).
+        self._base_url = (base_url or api_base()).rstrip("/")
 
     def report(
         self,
@@ -61,7 +63,7 @@ class FeedbackClient:
             payload["endUserId"] = end_user_id
 
         resp = requests.post(
-            f"{api_base()}/feedback",
+            f"{self._base_url}/feedback",
             headers={**get_headers(self._api_key), "Content-Type": "application/json"},
             json=payload,
             timeout=10,
@@ -79,7 +81,7 @@ class FeedbackClient:
         """All votes recorded on one trace, oldest first (``GET /feedback/trace/:traceId``) -
         the same rows the dashboard's trace dialog shows as up/down chips."""
         resp = requests.get(
-            f"{api_base()}/feedback/trace/{trace_id}",
+            f"{self._base_url}/feedback/trace/{trace_id}",
             headers=get_headers(self._api_key),
             timeout=10,
         )

agentx/monitor/client.py

@@ -85,9 +85,18 @@ class MonitorClient:
         from agentx.monitor.scorers import ScorersClient
         # Scorers-catalog administration as code: template enable/disable, code/external scorer
         # CRUD and dry runs - full parity with the dashboard's Scorers page (P1.3).
-        self.scorers = ScorersClient(api_key=api_key)
+        # Handed this client's own resolved API root, never the process-global default, so a
+        # second AgentX() with a different base_url can't re-point it (deep-dive bug #1).
+        self.scorers = ScorersClient(api_key=api_key, base_url=self._api_root())
+        from agentx.monitor.judge_scorers import JudgeScorersClient
+        # The unified LLM Judge Scorer (rubric + offline/online profiles in one entity) - the
+        # surface that matches the product; evaluations.settings and online_evaluators below
+        # remain as its profile-level views.
+        self.judge_scorers = JudgeScorersClient(api_key=api_key, base_url=self._api_root())
         self.profile = MonitorProfileClient(self)
-        self.online_evaluators = MonitorOnlineEvaluatorClient(self)
+        # Legacy view of an LLM Judge Scorer's online profile - constructed lazily so its
+        # DeprecationWarning fires on first USE, not for every client that never touches it.
+        self._online_evaluators: "MonitorOnlineEvaluatorClient | None" = None
         from agentx.monitor.sessions import MonitorSessionClient
         from agentx.monitor.agents import MonitorAgentClient
         self.sessions = MonitorSessionClient(self)
@@ -171,6 +180,14 @@ class MonitorClient:
         data = self._request("POST", "/online-evaluators", json=self._with_workspace(payload))
         return MonitorOnlineEvaluator(**data["evaluator"])
 
+    @property
+    def online_evaluators(self) -> "MonitorOnlineEvaluatorClient":
+        if self._online_evaluators is None:
+            from agentx.monitor.online_evaluators import MonitorOnlineEvaluatorClient
+
+            self._online_evaluators = MonitorOnlineEvaluatorClient(self)
+        return self._online_evaluators
+
     def list_online_evaluators(self) -> List[MonitorOnlineEvaluator]:
         data = self._request("GET", "/online-evaluators", params=self._workspace_params())
         return [MonitorOnlineEvaluator(**e) for e in data.get("evaluators", [])]

agentx/monitor/judge_scorers.py

@@ -0,0 +1,334 @@
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional
+
+import requests
+
+from agentx.util import api_base, get_headers
+
+logger = logging.getLogger(__name__)
+
+_SENTINEL: Any = object()
+
+
+class AgentXJudgeScorersError(Exception):
+    pass
+
+
+class JudgeScorer(dict):
+    """Wire object for the unified LLM Judge Scorer (dict subclass so unknown fields
+    round-trip). Convenience properties expose the pieces scripts reach for most."""
+
+    @property
+    def id(self) -> str:
+        return self["_id"]
+
+    @property
+    def name(self) -> str:
+        return self["name"]
+
+    @property
+    def judge(self) -> Dict[str, Any]:
+        return self.get("judge", {})
+
+    @property
+    def offline(self) -> Dict[str, Any]:
+        return self.get("offline", {})
+
+    @property
+    def online(self) -> Optional[Dict[str, Any]]:
+        return self.get("online")
+
+    @property
+    def online_profile_id(self) -> Optional[str]:
+        online = self.online
+        return online.get("profileId") if online else None
+
+
+class JudgeScorersClient:
+    """Surfaced as ``client.monitor.judge_scorers``: the unified LLM Judge Scorer.
+
+    One scorer = one judge rubric (``judge``: acceptance/rejection/evaluation criteria, judge
+    prompt, judge model) + two setting profiles:
+
+    - ``offline`` - how dataset runs grade with it (repetitions, similarity metrics, code
+      scorers, default/status). The scorer's ``id`` is exactly what
+      ``client.evaluations.run(dataset_id, scorer_id=scorer.id)`` takes.
+    - ``online`` - whether/how it scores live traffic (enabled, sample rate, scope,
+      alert threshold). ``None`` means offline-only.
+
+    Strictly one online profile per scorer. This supersedes the split between
+    ``client.evaluations.settings`` (the offline half) and ``client.monitor.online_evaluators``
+    (the online half) - both keep working, but this is the surface that matches the product.
+
+    Example::
+
+        scorer = client.monitor.judge_scorers.create(
+            "Support quality",
+            judge={"acceptanceCriteria": "Concrete, correct, cites the policy."},
+            online={"enabled": True, "sampleRate": 0.2, "alertThreshold": 6},
+        )
+        client.evaluations.run(dataset_id, subject, scorer_id=scorer.id)
+        cal = client.monitor.judge_scorers.calibration(scorer.id)
+    """
+
+    def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None):
+        self._api_key = api_key
+        # 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:
+        resp = requests.request(
+            method,
+            f"{self._base_url}/agent-monitoring{path}",
+            headers={**get_headers(self._api_key), "Content-Type": "application/json"},
+            json=json,
+            timeout=timeout,
+        )
+        if resp.status_code >= 400:
+            try:
+                detail = resp.json().get("error", resp.reason)
+            except ValueError:
+                detail = resp.reason
+            raise AgentXJudgeScorersError(f"Judge scorer request failed ({resp.status_code}): {detail}")
+        return resp.json() if resp.text else {}
+
+    # ------------------------------------------------------------------
+    # CRUD
+    # ------------------------------------------------------------------
+
+    def builder(
+        self,
+        name: str,
+        description: Optional[str] = None,
+        *,
+        # Judge rubric (shared by every surface that runs this scorer)
+        acceptance_criteria: Optional[str] = None,
+        rejection_criteria: Optional[str] = None,
+        evaluation_criteria: Optional[str] = None,
+        judge_prompt: Optional[str] = None,
+        judge_model: Optional[str] = None,
+        tool_context: Optional[str] = None,
+        # Offline profile (dataset-run grading)
+        number_of_requests: int = 1,
+        vector_similarity: bool = False,
+        jaccard_similarity: bool = False,
+        bleu_score: bool = False,
+        rouge_score: bool = False,
+        similarity_model: Optional[str] = None,
+        sovereignty_models: Optional[List[str]] = None,
+        thresholds: Optional[Dict[str, Any]] = None,
+        code_scorers: Optional[List[Dict[str, Any]]] = None,
+        is_default: bool = False,
+        # Online profile (live traffic). live=True enables scoring immediately - every check is
+        # a real judge call on your own key.
+        live: bool = False,
+        sample_rate: float = 0.1,
+        scope: str = "trace",
+        alert_threshold: Optional[float] = 5,
+        severity: str = "medium",
+        agent_ids: Optional[List[str]] = None,
+        idle_seconds: int = 120,
+    ) -> "JudgeScorerBuilder":
+        """Snake_case builder with ``.publish()``, the unified successor of
+        ``client.evaluations.settings.builder(...)`` - same offline fields (plus ``thresholds``,
+        ``tool_context``) and, new here, the online profile in the same call. The scorer the
+        builder publishes is one entity: its ``.id`` is what ``client.evaluations.run(...,
+        scorer_id=...)`` takes, and its live profile is what online scoring keys on."""
+        judge: Dict[str, Any] = {}
+        for key, value in (
+            ("acceptanceCriteria", acceptance_criteria),
+            ("rejectionCriteria", rejection_criteria),
+            ("evaluationCriteria", evaluation_criteria),
+            ("judgePrompt", judge_prompt),
+            ("judgeModel", judge_model),
+            ("toolContext", tool_context),
+        ):
+            if value is not None:
+                judge[key] = value
+        offline: Dict[str, Any] = {"numberOfRequests": number_of_requests, "isDefault": is_default}
+        if vector_similarity:
+            offline["vectorSimilarity"] = (
+                {"enabled": True, "model": similarity_model} if similarity_model else {"enabled": True}
+            )
+        if jaccard_similarity:
+            offline["jaccardSimilarity"] = {"enabled": True}
+        if bleu_score:
+            offline["bleuScore"] = {"enabled": True}
+        if rouge_score:
+            offline["rougeScore"] = {"enabled": True}
+        if sovereignty_models is not None:
+            offline["sovereigntyIndex"] = {"enabled": bool(sovereignty_models), "models": sovereignty_models}
+        if thresholds is not None:
+            offline["thresholds"] = thresholds
+        if code_scorers is not None:
+            offline["codeScorers"] = code_scorers
+        online: Optional[Dict[str, Any]] = None
+        if live:
+            online = {
+                "enabled": True,
+                "sampleRate": sample_rate,
+                "scope": scope,
+                "alertThreshold": alert_threshold,
+                "severity": severity,
+                "idleSeconds": idle_seconds,
+            }
+            if agent_ids:
+                online["scopeMode"] = "selected"
+                online["agentIds"] = agent_ids
+        return JudgeScorerBuilder(self, name=name, description=description, judge=judge, offline=offline, online=online)
+
+    def create(
+        self,
+        name: str,
+        *,
+        description: Optional[str] = None,
+        judge: Optional[Dict[str, Any]] = None,
+        offline: Optional[Dict[str, Any]] = None,
+        online: Optional[Dict[str, Any]] = None,
+    ) -> JudgeScorer:
+        """Create a scorer. ``online=None`` (default) creates it offline-only; pass e.g.
+        ``online={"enabled": True, "sampleRate": 0.1, "alertThreshold": 5}`` to score live
+        traffic from the start. Section dicts use the wire's camelCase keys."""
+        payload: Dict[str, Any] = {"name": name}
+        if description is not None:
+            payload["description"] = description
+        if judge is not None:
+            payload["judge"] = judge
+        if offline is not None:
+            payload["offline"] = offline
+        if online is not None:
+            payload["online"] = online
+        return JudgeScorer(self._request("POST", "/judge-scorers", json=payload)["judgeScorer"])
+
+    def get(self, scorer_id: str) -> JudgeScorer:
+        return JudgeScorer(self._request("GET", f"/judge-scorers/{scorer_id}")["judgeScorer"])
+
+    def list(self) -> List[JudgeScorer]:
+        return [JudgeScorer(s) for s in self._request("GET", "/judge-scorers").get("judgeScorers", [])]
+
+    def update(
+        self,
+        scorer_id: str,
+        *,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        judge: Optional[Dict[str, Any]] = None,
+        offline: Optional[Dict[str, Any]] = None,
+        online: Any = _SENTINEL,
+    ) -> JudgeScorer:
+        """Sparse update: only the sections you pass change. ``online={...}`` upserts the
+        online profile (this is how an offline-only scorer goes live); ``online=None``
+        detaches it (refused for the built-in Session Baseline Judge)."""
+        payload: Dict[str, Any] = {}
+        if name is not None:
+            payload["name"] = name
+        if description is not None:
+            payload["description"] = description
+        if judge is not None:
+            payload["judge"] = judge
+        if offline is not None:
+            payload["offline"] = offline
+        if online is not _SENTINEL:
+            payload["online"] = online
+        return JudgeScorer(self._request("PUT", f"/judge-scorers/{scorer_id}", json=payload)["judgeScorer"])
+
+    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}")
+
+    # ------------------------------------------------------------------
+    # Online-profile pass-throughs (calibration / tuning / ratings / events)
+    # These endpoints key on the online profile's id, resolved here so callers only ever
+    # handle the scorer id.
+    # ------------------------------------------------------------------
+
+    def _profile_id(self, scorer_id: str) -> str:
+        scorer = self.get(scorer_id)
+        profile_id = scorer.online_profile_id
+        if not profile_id:
+            raise AgentXJudgeScorersError(
+                f"Judge scorer {scorer_id!r} has no online profile - calibration/tuning/ratings "
+                "cover live-traffic scoring. Give it one first: "
+                "update(scorer_id, online={'enabled': True})."
+            )
+        return profile_id
+
+    def calibration(self, scorer_id: str, window: str = "7d") -> dict:
+        """How this scorer's verdicts compare against recorded ground truth (triage
+        corrections, outcomes, end-user votes) over the window."""
+        return self._request("GET", f"/online-evaluators/{self._profile_id(scorer_id)}/calibration?window={window}")
+
+    def tune(self, scorer_id: str, window: str = "7d") -> dict:
+        """Propose a rewrite of the rubric from calibration disagreements (LLM call, slow)."""
+        data = self._request(
+            "POST", f"/online-evaluators/{self._profile_id(scorer_id)}/tune", json={"window": window}, timeout=300
+        )
+        # The wire wraps the proposal ({"proposal": {...}}); unwrap like the legacy client so
+        # proposal["reasoning"] / the criteria fields are directly addressable.
+        return data.get("proposal", data) if isinstance(data, dict) else data
+
+    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.
+        return self._request(
+            "POST",
+            f"/online-evaluators/{self._profile_id(scorer_id)}/tune/validate",
+            json={**criteria, "window": window},
+            timeout=600,
+        )
+
+    def publish_tuning(self, scorer_id: str, criteria: Dict[str, Any]) -> dict:
+        """Write tuned criteria onto the scorer's rubric - it applies everywhere the scorer is
+        used: online scoring, offline dataset runs, and the playground."""
+        return self._request(
+            "POST", f"/online-evaluators/{self._profile_id(scorer_id)}/tune/publish", json=dict(criteria)
+        )
+
+    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
+        the legacy online_evaluators client returns, so scripts migrate without shape changes."""
+        from agentx.monitor.models import OnlineEvaluatorRatingPoint
+
+        data = self._request("GET", f"/online-evaluators/{self._profile_id(scorer_id)}/ratings?window={window}")
+        return [OnlineEvaluatorRatingPoint(**p) for p in data.get("points", [])]
+
+    def events(self, scorer_id: str, window: str = "7d") -> "List[OnlineEvaluatorEvent]":
+        """Individually scored traces behind the ratings series, worst-rated first - typed, same
+        as the legacy online_evaluators client."""
+        from agentx.monitor.models import OnlineEvaluatorEvent
+
+        data = self._request("GET", f"/online-evaluators/{self._profile_id(scorer_id)}/events?window={window}")
+        return [OnlineEvaluatorEvent(**e) for e in data.get("events", [])]
+
+
+class JudgeScorerBuilder:
+    """Assembled by :meth:`JudgeScorersClient.builder`; ``.publish()`` creates the scorer."""
+
+    def __init__(
+        self,
+        client: "JudgeScorersClient",
+        *,
+        name: str,
+        description: Optional[str],
+        judge: Dict[str, Any],
+        offline: Dict[str, Any],
+        online: Optional[Dict[str, Any]],
+    ):
+        self._client = client
+        self._name = name
+        self._description = description
+        self._judge = judge
+        self._offline = offline
+        self._online = online
+
+    def publish(self) -> JudgeScorer:
+        return self._client.create(
+            self._name,
+            description=self._description,
+            judge=self._judge or None,
+            offline=self._offline or None,
+            online=self._online,
+        )

agentx/monitor/online_evaluators.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+import warnings
 from typing import Any, Dict, List, Optional, TYPE_CHECKING
 
 from agentx.monitor.models import MonitorOnlineEvaluator, OnlineEvaluatorRatingPoint, OnlineEvaluatorEvent
@@ -17,7 +18,12 @@ class MonitorOnlineEvaluatorBuilder:
     ``evaluation_settings_id`` must reference an existing Evaluator config (criteria, judge
     prompt, judge model), the same config datasets/Evaluate runs use, see
     ``client.evaluations.settings.builder(...)``.
-    """
+
+    Note: an online evaluator is the ONLINE profile of an **LLM Judge Scorer** - the unified
+    entity at ``client.monitor.judge_scorers``. Strictly one profile per config since the
+    unification: binding a config that is already another evaluator's profile transparently
+    binds a fresh copy of it instead (the response's ``evaluationSettingsId`` is the copy).
+    This surface keeps working unchanged; prefer ``judge_scorers`` for new code."""
 
     def __init__(
         self,
@@ -60,10 +66,23 @@ class MonitorOnlineEvaluatorBuilder:
 
 
 class MonitorOnlineEvaluatorClient:
-    """Thin wrapper surfaced as ``client.monitor.online_evaluators``."""
+    """Thin wrapper surfaced as ``client.monitor.online_evaluators``.
+
+    Note: an online evaluator is the ONLINE (live-traffic) profile of an **LLM Judge Scorer** -
+    the unified entity at ``client.monitor.judge_scorers``, which also carries the judge rubric
+    and the offline profile. This client keeps working unchanged; prefer ``judge_scorers`` for
+    new code so both profiles live in one place."""
 
     def __init__(self, client: "MonitorClient"):
         self._client = client
+        # Soft deprecation: hidden by default (DeprecationWarning), visible under -W or pytest.
+        warnings.warn(
+            "client.monitor.online_evaluators is the legacy view of an LLM Judge Scorer's "
+            "online profile; prefer client.monitor.judge_scorers, which manages the judge "
+            "rubric, offline profile, and online profile as one entity.",
+            DeprecationWarning,
+            stacklevel=3,
+        )
 
     def builder(
         self,

agentx/monitor/scorers.py

@@ -33,13 +33,15 @@ class ScorersClient:
     wire.
     """
 
-    def __init__(self, api_key: Optional[str] = None):
+    def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None):
         self._api_key = api_key
+        # 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:
         resp = requests.request(
             method,
-            f"{api_base()}/agent-monitoring{path}",
+            f"{self._base_url}/agent-monitoring{path}",
             headers={**get_headers(self._api_key), "Content-Type": "application/json"},
             json=json,
             params=params,

agentx/outcomes.py

@@ -26,8 +26,10 @@ class OutcomesClient:
     tracker's webhook, a CRM workflow), and this method is the SDK's way to be that caller.
     """
 
-    def __init__(self, api_key: Optional[str] = None):
+    def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None):
         self._api_key = api_key
+        # Captured once at construction (deep-dive round 3, bug #1).
+        self._base_url = (base_url or api_base()).rstrip("/")
 
     def report(
         self,
@@ -69,7 +71,7 @@ class OutcomesClient:
             payload["reportedBy"] = reported_by
 
         resp = requests.post(
-            f"{api_base()}/outcomes",
+            f"{self._base_url}/outcomes",
             headers={**get_headers(self._api_key), "Content-Type": "application/json"},
             json=payload,
             timeout=10,

agentx/projects.py

@@ -25,13 +25,16 @@ class ProjectsClient:
     users; this client covers the default self-host (auth-disabled) mode.
     """
 
-    def __init__(self, api_key: Optional[str] = None):
+    def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None):
         self._api_key = api_key
+        # Captured once at construction so two clients with different bases can coexist
+        # (deep-dive round 3, bug #1) - never read from process-global state per call.
+        self._base_url = (base_url or api_base()).rstrip("/")
 
     def _request(self, method: str, path: str, json: Any = None) -> Any:
         resp = requests.request(
             method,
-            f"{api_base()}{path}",
+            f"{self._base_url}{path}",
             headers={**get_headers(self._api_key), "Content-Type": "application/json"},
             json=json,
             timeout=15,

agentx/traces.py

@@ -24,12 +24,14 @@ class TracesClient:
     span-tree read.
     """
 
-    def __init__(self, api_key: Optional[str] = None):
+    def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None):
         self._api_key = api_key
+        # Captured once at construction (deep-dive round 3, bug #1).
+        self._base_url = (base_url or api_base()).rstrip("/")
 
     def _request(self, path: str, params: Optional[Dict[str, Any]] = None) -> Any:
         resp = requests.get(
-            f"{api_base()}{path}",
+            f"{self._base_url}{path}",
             headers=get_headers(self._api_key),
             params=params or {},
             timeout=15,

agentx/tracing/ingest_client.py

@@ -72,6 +72,11 @@ class IngestClient:
         # failures stay at DEBUG to avoid log spam. client.ping() is the fail-fast startup check.
         self._delivery_warning_emitted = False
 
+        # Dropped-trace accounting (deep-dive round 3, bug #5): fire-and-forget may drop traces
+        # (queue overflow, retries exhausted while the engine is down), but it must never drop
+        # them SILENTLY. First drop warns, then every 50th, with the cumulative count.
+        self._dropped = 0
+
         self._queue: queue.Queue[Optional[Dict[str, Any]]] = queue.Queue(maxsize=_QUEUE_MAX)
         self._worker = threading.Thread(target=self._drain, daemon=True, name="agentx-ingest")
         self._worker.start()
@@ -90,11 +95,44 @@ class IngestClient:
         try:
             self._queue.put_nowait(payload)
         except queue.Full:
-            logger.debug("agentx ingest queue full - trace dropped")
+            self._record_drop("queue full")
+
+    def flush(self, timeout: float = 5.0) -> bool:
+        """Block until all queued traces have been sent, or until ``timeout`` seconds elapse.
 
-    def flush(self, timeout: float = 5.0) -> None:
-        """Block until all queued traces have been sent (or timeout elapses)."""
-        self._queue.join()
+        Returns ``True`` when the queue fully drained, ``False`` on deadline - undelivered
+        traces stay queued and keep sending in the background. The old implementation called
+        ``queue.join()``, which has no deadline at all: with the engine down, each queued item
+        burned the full retry backoff and a ``flush(timeout=3)`` measurably blocked for over
+        two minutes (deep-dive round 3, bug #5). The timeout is now a real wall-clock bound.
+        """
+        deadline = time.time() + timeout
+        with self._queue.all_tasks_done:
+            while self._queue.unfinished_tasks:
+                remaining = deadline - time.time()
+                if remaining <= 0:
+                    logger.warning(
+                        "agentx flush(%.1fs) timed out with %d trace(s) still undelivered - "
+                        "they remain queued and keep sending in the background",
+                        timeout,
+                        self._queue.unfinished_tasks,
+                    )
+                    return False
+                self._queue.all_tasks_done.wait(remaining)
+        return True
+
+    def _record_drop(self, reason: str) -> None:
+        self._dropped += 1
+        if self._dropped == 1 or self._dropped % 50 == 0:
+            logger.warning(
+                "agentx dropped a trace (%s) - %d dropped total this process. "
+                "Tracing is fire-and-forget: traces that cannot be delivered are not persisted "
+                "locally. Use client.ping() at startup to fail fast on a bad endpoint.",
+                reason,
+                self._dropped,
+            )
+        else:
+            logger.debug("agentx dropped a trace (%s), %d total", reason, self._dropped)
 
     def send_trace_sync(self, payload: Dict[str, Any]) -> Optional[str]:
         """
@@ -372,7 +410,9 @@ class IngestClient:
             try:
                 self._send(payload)
             except Exception as exc:
-                logger.debug("agentx ingest send error: %s", exc)
+                # Anything _send didn't classify still cost us this payload - count it as a
+                # drop rather than whispering at DEBUG (bug #5's silent half).
+                self._record_drop(f"unexpected error: {exc}")
             finally:
                 self._queue.task_done()
 
@@ -397,4 +437,4 @@ class IngestClient:
             return
 
         self._warn_delivery(str(last_exc))
-        logger.debug("agentx ingest failed after retries: %s", last_exc)
+        self._record_drop(f"retries exhausted: {last_exc}")

agentx/tracing/tracer.py

@@ -890,9 +890,11 @@ class Tracer:
             agent_id=agent_id,
         )
 
-    def flush(self, timeout: float = 5.0) -> None:
-        """Block until all queued traces have been delivered."""
-        self._client.flush(timeout)
+    def flush(self, timeout: float = 5.0) -> bool:
+        """Block until all queued traces have been delivered, or until ``timeout`` seconds
+        elapse. Returns ``True`` when everything drained, ``False`` on deadline (a warning is
+        logged and undelivered traces keep sending in the background)."""
+        return self._client.flush(timeout)
 
     # ------------------------------------------------------------------
     # CI/CD evaluation

agentx/version.py

@@ -1 +1 @@
-VERSION = "0.6.34"
+VERSION = "0.6.36"

{agentx_python-0.6.34.dist-info → agentx_python-0.6.36.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentx-python
-Version: 0.6.34
+Version: 0.6.36
 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

{agentx_python-0.6.34.dist-info → agentx_python-0.6.36.dist-info}/RECORD

@@ -1,25 +1,25 @@
 agentx/__init__.py,sha256=4iMiGLNU4S-I-WyX0Z7l0BFUY_krVJ3seMQPqyO-ReA,602
-agentx/agentx.py,sha256=xNtG_g51_QKn1fRSAXYC18mYsxLwnvajoSSiwxYDtmI,7858
+agentx/agentx.py,sha256=WuzVQtXSPqBhRwKxkUlQ8VG2cwvGpbMcti4n6aTNPwA,8816
 agentx/cli.py,sha256=ueKYPBhW8qd63nvQBQeZ4Mgz9NwEVaM0KH2WvLQ0bGs,6097
 agentx/exceptions.py,sha256=2tDLdZjriFBQbjgzyIcah12RazpbujhqZSRbSXgAml4,1377
-agentx/export.py,sha256=Pvz-0vXUHnKx7_KPrr5kzXMsMdTk1LMX-4CB3k0AgMI,4094
-agentx/feedback.py,sha256=ZNM89mfKtjkbDZefbGWuej-pqSwlnjAnIS6oQ-Tw09M,3472
-agentx/outcomes.py,sha256=wD03oNUuFv56_l1ebOSTbWJ6XqSU7_QXnWzMZ5G3RDU,3295
-agentx/projects.py,sha256=er9OdY-IISB5Xn16Auolmh2lnKDF6E4M4nPAvR7NZbM,2267
+agentx/export.py,sha256=FNT00e-j9AQRkNDksUwgHJXgr8-XVPscEH4xUqJHmfM,4265
+agentx/feedback.py,sha256=hMPU3ivUHvhOXOH7gvT4Jy1yztVmoIMOw1MbUNRs5Gk,3643
+agentx/outcomes.py,sha256=yCA6PrO5BrGufEjkzYWTK5wusAOt6w0gSKkH-5x1Fs4,3462
+agentx/projects.py,sha256=JN-nhesELPjEb1P0m9F4-Qw-0eGR68kCtBN5zNhArt0,2540
 agentx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-agentx/traces.py,sha256=9QfTgGlwHkqPMY7lkF-LVk1SqcTWFtsuliu2ChDi6cE,2120
+agentx/traces.py,sha256=sz9gxutlDKNgf0fdCkyzKsGwK5eMAJuIEl3NIwGrsuo,2287
 agentx/util.py,sha256=lt2Kpg4Fj8whrSuAhLEahcPEIYRVpK9RCC5y9ShdTJs,703
-agentx/version.py,sha256=No3CH7gRh0Bs49mgkkl6NBX4xs2x7o3PFlV4yDIt7Ho,19
+agentx/version.py,sha256=Vjh1dxR-kRQ3D_9qSk_EH1XFCc8RMkJ2gALg30ZZ0ns,19
 agentx/evaluations/__init__.py,sha256=Erv7RGFlRxGTG4rVb2uHhCqLLEX_iAWKqkZKzK6CumE,262
 agentx/evaluations/_term.py,sha256=WFpiNzdgDBeJJ-Gg-6X7TwwxllobuE4OqFUTuDQvS3Y,2529
-agentx/evaluations/client.py,sha256=GoYWV0v_4AJRwdwohyfGrICe2QNi6Q2WjS1sgaJQ16g,25837
-agentx/evaluations/datasets.py,sha256=cLJ0syj-e3uvCGJbBDQvYibNPVTIoh09_Z0XVqsYMgY,14007
-agentx/evaluations/evaluation_settings.py,sha256=SrCUZ9gObXLemJ8HLx9WHaUv18d9HANAEIDez_xHR8E,5273
-agentx/evaluations/models.py,sha256=FG0JqNDB_CzuPvXbD9Ky-tbjhrYGizY1xyoAEGzWja0,28675
+agentx/evaluations/client.py,sha256=Vo3pvD37f6Z8VgUm3DR0FzSmnO3qYcokGHmiTc8RzwU,27273
+agentx/evaluations/datasets.py,sha256=7OYj5pXpJenViAhPe7Sr_7Sf9KWd7b1OhV-dPL2tso8,14283
+agentx/evaluations/evaluation_settings.py,sha256=geRydHqKpxwkxBVfMIOqkB6NlStyOZrYwZnMHluDwvA,6276
+agentx/evaluations/models.py,sha256=iXM1XReT1PLxjVjgdfMuomFOSAwFhHAY4qBxNjiKw88,28732
 agentx/evaluations/prompts.py,sha256=8xyvMpAl3mD5xuSZozuaohdnCBWe5Q02RldwiPLUO20,3493
 agentx/evaluations/reporting.py,sha256=GtNnL-1eNEQrSqd0yrHi5mGqC9_u0kUAN8Mbjdhw6yY,6389
 agentx/evaluations/results.py,sha256=w7TRUik4eXIqrznXvlF_L9hnObnHvgdRKvihfN1XeAU,4692
-agentx/evaluations/runner.py,sha256=lVpdR4oIYQ7MCTT7Zn8Ono9Mrb7XCQZ5eMDEZr7njc8,26234
+agentx/evaluations/runner.py,sha256=wXBUzYvdS_7dlcnIlJQXSWfjGdC0BfWiu4_Ki1rLYtg,26567
 agentx/evaluations/tool_schemas.py,sha256=ZyrnSOnx9xlSAj4swfDey9ZLS2ly-g21DByTwRAGwNA,2323
 agentx/evaluations/tracing.py,sha256=MSJD9bzfInMi7E70mc8mWUc0fx5DLkOgUzRru2mNQoc,1825
 agentx/evaluations/adapters/__init__.py,sha256=fK8Hx75usbiY03XUSmnLnSrwBXip2CQs24YZcdEgj6w,287
@@ -42,12 +42,13 @@ agentx/integrations/openai.py,sha256=1KLs-hJaeW2emHPwNkmC3zcGksL3zd87uWbcLGRW704
 agentx/integrations/openai_agents.py,sha256=tCa3kPxqux5LnNNDQ6zA05OybQrjkc_LeE08YuNPJEs,12742
 agentx/monitor/__init__.py,sha256=MLiASSvQnCy2jqVNRTgPWFhUSf8lGYRQeEgEVVhE5Tg,574
 agentx/monitor/agents.py,sha256=8Xk4jWmNTvdtjFixHiLmw4jj96uqIXWIT6KW8zXoWrc,1006
-agentx/monitor/client.py,sha256=phdBAzQSsw8TiaFMPQJ1jPdKGxZdywxZA7G4h7P7t3o,15535
+agentx/monitor/client.py,sha256=BXaTDAsKJf_3uwrhZMKn4UqAz5Xr0qap-MH9a-CR7d8,16655
+agentx/monitor/judge_scorers.py,sha256=40Xq60QASLW9z2QT2dSTmZhILGeBTfFGLrog5yeessM,14261
 agentx/monitor/models.py,sha256=yTC3WTdTziHMkdeAXlTro-4YiSbBUHMgf9kNZHGfPDA,8470
-agentx/monitor/online_evaluators.py,sha256=gfGMgJLIWjPUpYK068fxv2oZerHi3o0_4AOjxoVQhak,7176
+agentx/monitor/online_evaluators.py,sha256=tTXqRgOb6ah39c5nWMEVXLxEUc8Tqu9E9SFdcHy0ExM,8418
 agentx/monitor/patterns.py,sha256=ruBqLoA2T2KQuqRbbn1kWkIEkiOal3SvyPl9opGyhzI,4185
 agentx/monitor/profile.py,sha256=uGk-4bXT2vmnEQiY5u6rWhAfzZchHBXL74VD3piVHvU,3102
-agentx/monitor/scorers.py,sha256=67QWvy6EDW17II9hgfZY47moISuAXt2-hTRHdbHDD2I,7169
+agentx/monitor/scorers.py,sha256=huIZBszrfLKI8I7VV6NFpW6piRsj9HI03rXUwWs2tgs,7336
 agentx/monitor/sessions.py,sha256=gePcL284m3UITxQAtHxwrKFl6bRjmRib1QK6JbZeS9s,815
 agentx/monitor/signals.py,sha256=Ld11lW2lbg8NHBUHdgoY6iwCvJDK-eg4ge4qQ9y7nGY,1432
 agentx/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -56,11 +57,11 @@ agentx/resources/conversation.py,sha256=94pOdM6Pmj67RhikZVBNGkT3V-WKK_ZAD7s27p5-
 agentx/resources/workforce.py,sha256=lfGVkoV9lcOp-lZScjTvwRarJMkhzfMfLm4syJDujGc,4168
 agentx/tracing/__init__.py,sha256=l2mIRILE-wWrCD0fekgrIOQUEvtDObzdrkgpQUtXroU,408
 agentx/tracing/ci_types.py,sha256=zFVcZGvc1qbVDdOlEPQ1i5R6terqJHxCzFF4ZjouxxI,1423
-agentx/tracing/ingest_client.py,sha256=TuKQAVeKi35Nv8oMGIHxw-vR8Lg_4NtpzBQHouxljFk,15517
-agentx/tracing/tracer.py,sha256=zv5iNXyHXSZ8QW5yBe-Pk3kauLhaFAeQii3YDZchQwE,51366
-agentx_python-0.6.34.dist-info/licenses/LICENSE,sha256=gZVsM-nLsE8vlaY6NXXsVoo6IlCClxkToAWmhgT3y_s,10762
-agentx_python-0.6.34.dist-info/METADATA,sha256=P4C9ErZLr2n6Mblzw7j_DwT7Lwa861c_7SwYnreToAA,20133
-agentx_python-0.6.34.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-agentx_python-0.6.34.dist-info/entry_points.txt,sha256=rQqF1JTY3T1yfviBU1r8PU-5mBdfOk6P4bZ1L4BskIM,172
-agentx_python-0.6.34.dist-info/top_level.txt,sha256=s-q-HB9Gb_QdrZNacSeQyF_c25gQooMy7DlxzgLOHPk,7
-agentx_python-0.6.34.dist-info/RECORD,,
+agentx/tracing/ingest_client.py,sha256=5X6RyxtMq1XYgOzsMd3b2f2qpmYpsMnhKm7NB3oup00,17664
+agentx/tracing/tracer.py,sha256=6qLTrV4Fz_ONitlBMKiayRbeoV1dpkTwskTDP5oVt4I,51567
+agentx_python-0.6.36.dist-info/licenses/LICENSE,sha256=gZVsM-nLsE8vlaY6NXXsVoo6IlCClxkToAWmhgT3y_s,10762
+agentx_python-0.6.36.dist-info/METADATA,sha256=lqDEHXO2-wFeK4cx6hGiU1hI-cE_4t92idDVwvza8q8,20133
+agentx_python-0.6.36.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+agentx_python-0.6.36.dist-info/entry_points.txt,sha256=rQqF1JTY3T1yfviBU1r8PU-5mBdfOk6P4bZ1L4BskIM,172
+agentx_python-0.6.36.dist-info/top_level.txt,sha256=s-q-HB9Gb_QdrZNacSeQyF_c25gQooMy7DlxzgLOHPk,7
+agentx_python-0.6.36.dist-info/RECORD,,