agentx-python 0.8.19__tar.gz → 0.8.20__tar.gz

{agentx_python-0.8.19/agentx_python.egg-info → agentx_python-0.8.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentx-python
-Version: 0.8.19
+Version: 0.8.20
 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.8.19 → agentx_python-0.8.20}/agentx/__init__.py

@@ -12,11 +12,10 @@ from agentx.exceptions import (
     CIGateFailure,
 )
 
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    datefmt="%Y-%m-%d %H:%M:%S %Z",
-)
+# Library logging hygiene: a library must never call logging.basicConfig - it hijacks the
+# host application's root logger (format AND level) and turns the app's own later basicConfig
+# into a no-op. Consumers opt into our logs with logging.getLogger("agentx").setLevel(...).
+logging.getLogger("agentx").addHandler(logging.NullHandler())
 
 __all__ = [
     "AgentX",

{agentx_python-0.8.19 → agentx_python-0.8.20}/agentx/evaluations/client.py

@@ -348,7 +348,9 @@ class EvaluationsClient:
             payload["scorerGroupId"] = scorer_group_id
         if split:
             payload["split"] = split
-        data = self._request("POST", "/runs", json=self._with_workspace(payload))
+        # Server-side write: a timeout after the run row was created would be
+        # retried into a duplicate run, so no transport retry.
+        data = self._request("POST", "/runs", json=self._with_workspace(payload), retry=False)
         return EvaluationRun(**data)
 
     def append_results(
@@ -432,8 +434,12 @@ class EvaluationsClient:
 
         if not self._analysis_on_dashboard_router:
             try:
+                # The self-host route runs the analysis SYNCHRONOUSLY (engine
+                # routes/evaluations.ts) - a short timeout with retries re-billed the whole
+                # multi-judge analysis up to 4x while the first was still running. Full
+                # analysis timeout, no transport retry.
                 return self._request(
-                    "POST", f"/runs/{run_id}/analyze", json=payload, timeout=30
+                    "POST", f"/runs/{run_id}/analyze", json=payload, timeout=1800, retry=False
                 )
             except AgentXEvaluationsError as exc:
                 if not self._note_missing_analysis_route(exc, "analyze"):
@@ -554,13 +560,17 @@ class EvaluationsClient:
         if isinstance(dataset_id, dict):  # populated reference, not a bare id
             dataset_id = dataset_id.get("_id") or dataset_id.get("id")
 
-        return Report(
-            runId=run_id,
-            datasetId=dataset_id or "",
-            status=envelope.get("status") or "completed",
-            statistics=envelope.get("statistics"),
+        # Built as one merged dict (explicit keys last, so they win) - passing the
+        # explicit keys as keyword arguments alongside **body raises "got multiple
+        # values" whenever the analysis body itself carries runId/datasetId/status/
+        # statistics.
+        return Report(**{
             **body,
-        )
+            "runId": run_id,
+            "datasetId": dataset_id or "",
+            "status": envelope.get("status") or "completed",
+            "statistics": envelope.get("statistics"),
+        })
 
     # ------------------------------------------------------------------
     # Prompt improvement loop (examples -> propose -> publish). These ride the engine's
@@ -589,8 +599,11 @@ class EvaluationsClient:
             payload["reasoning"] = reasoning
         if based_on_version is not None:
             payload["basedOnVersion"] = based_on_version
+        # Server-side write: a timeout after the version was stored would be
+        # retried into a duplicate version, so no transport retry.
         return self._request(
-            "POST", f"/evaluate/prompts/{prompt_id}/versions", base=self._api_root, json=payload
+            "POST", f"/evaluate/prompts/{prompt_id}/versions", base=self._api_root, json=payload,
+            retry=False,
         )
 
     # ------------------------------------------------------------------
@@ -628,7 +641,7 @@ class EvaluationsClient:
             payload["judgeModel"] = judge_model
         if both_orders:
             payload["bothOrders"] = True
-        response = self._request("POST", "/evaluate/runs/pairwise", json=payload, base=self._api_root)
+        response = self._request("POST", "/evaluate/runs/pairwise", json=payload, base=self._api_root, timeout=900, retry=False,)
         return PairwiseComparison(**response["comparison"])
 
     def get_pairwise(self, batch_id: str) -> PairwiseComparison:
@@ -662,7 +675,8 @@ class EvaluationsClient:
         payload: dict = {"name": name, "definition": definition}
         if description is not None:
             payload["description"] = description
-        return self._request("POST", "/evaluate/tool-schemas", base=self._api_root, json=payload)
+        # Server-side write - no transport retry (see init_run's comment).
+        return self._request("POST", "/evaluate/tool-schemas", base=self._api_root, json=payload, retry=False)
 
     def get_tool_schema_examples(self, tool_schema_id: str, window: Optional[str] = None) -> dict:
         params = {"window": window} if window else None
@@ -686,8 +700,10 @@ class EvaluationsClient:
             payload["reasoning"] = reasoning
         if based_on_version is not None:
             payload["basedOnVersion"] = based_on_version
+        # Server-side write - no transport retry (see init_run's comment).
         return self._request(
-            "POST", f"/evaluate/tool-schemas/{tool_schema_id}/versions", base=self._api_root, json=payload
+            "POST", f"/evaluate/tool-schemas/{tool_schema_id}/versions", base=self._api_root, json=payload,
+            retry=False,
         )
 
     # ------------------------------------------------------------------

{agentx_python-0.8.19 → agentx_python-0.8.20}/agentx/evaluations/datasets.py

@@ -16,7 +16,13 @@ _REQUIRED_CSV_COLS = {"query"}
 
 
 class DatasetBuilder:
-    """Fluent builder for creating a Custom Agent Evaluations dataset."""
+    """Fluent builder for creating a Custom Agent Evaluations dataset.
+
+    ``judge_prompt``/``judge_model`` are LLM-as-judge overrides for the dataset's grading
+    config. NOTE (self-host): the engine's dataset-create route currently ignores both -
+    set them on a judge scorer / the evaluation settings instead. ``sovereignty_models``
+    is accepted on the wire but not acted on by the self-host engine.
+    """
 
     def __init__(
         self,
@@ -50,6 +56,8 @@ class DatasetBuilder:
         # LLM-as-judge overrides for this dataset's own grading config. Omit either to keep the
         # server default (raw prompt template / gpt-5.6-luna, see EVALUATIONS.md). judge_model
         # must be one of client.evaluations.list_models() (OpenAI or Anthropic).
+        # Self-host: the dataset-create route currently IGNORES judgePrompt/judgeModel - set
+        # them on a judge scorer / the evaluation settings instead (see class docstring).
         if judge_prompt is not None:
             self._payload["judgePrompt"] = judge_prompt
         if judge_model is not None:
@@ -84,7 +92,8 @@ class DatasetBuilder:
         if rouge_score:
             self._payload["rougeScore"] = {"enabled": True}
         # Sovereignty & Portability - the models to compare on this dataset (use
-        # client.evaluations.list_models() to discover valid ids).
+        # client.evaluations.list_models() to discover valid ids). Self-host: accepted on
+        # the wire but not acted on by the engine (see class docstring).
         if sovereignty_models:
             self._payload["sovereigntyIndex"] = {
                 "enabled": True,
@@ -354,10 +363,13 @@ class DatasetClient:
             "acceptanceCriteria",
             "rejectionCriteria",
             "evaluationCriteria",
+            "judgePrompt",
+            "judgeModel",
             "vectorSimilarity",
             "jaccardSimilarity",
             "bleuScore",
             "rougeScore",
+            "sovereigntyIndex",
             "codeScorers",
         ):
             if wire.get(key) is not None:

{agentx_python-0.8.19 → agentx_python-0.8.20}/agentx/evaluations/reporting.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from typing import Optional
+
 from agentx.evaluations.models import Report
 from agentx.evaluations._term import (
     bold,
@@ -21,14 +23,14 @@ _RATING_ICONS = {"high": "●", "medium": "◑", "low": "○"}
 _PRI_COLORS = {"high": red, "medium": yellow, "low": dim}
 
 
-def _rating_badge(rating: str | None) -> str:
+def _rating_badge(rating: Optional[str]) -> str:
     icon = _RATING_ICONS.get(rating or "", "·")
     color = _RATING_COLORS.get(rating or "", dim)
     label = (rating or "").upper()
     return color(f"{icon} {label}") if label else dim(icon)
 
 
-def _section(title: str, rating: str | None = None) -> None:
+def _section(title: str, rating: Optional[str] = None) -> None:
     badge = f"  {_rating_badge(rating)}" if rating else ""
     print(f"\n{bold(title)}{badge}")
     print(dim(_THIN))

{agentx_python-0.8.19 → agentx_python-0.8.20}/agentx/evaluations/runner.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 import logging
 import os
 import time
+
+import requests
 import uuid
 from typing import Any, Callable, Dict, Iterator, List, Optional, Set, Union
 
@@ -304,6 +306,12 @@ class EvaluationRunContext:
                         resp.failed_validation,
                     )
                     return
+                except requests.Timeout as exc:
+                    # A read timeout means the engine may STILL be scoring this batch - a
+                    # retry re-POSTs it and double-bills every judge call (idempotency keys
+                    # protect rows already inserted, not judge work mid-flight). Fail loud.
+                    last_exc = exc
+                    break
                 except Exception as exc:
                     last_exc = exc
                     if attempt == 1:

{agentx_python-0.8.19 → agentx_python-0.8.20}/agentx/integrations/anthropic.py

@@ -274,7 +274,7 @@ def _patch_stream(
                 return iter(ctx)
 
             def __aiter__(self_inner):
-                return aiter(ctx)
+                return ctx.__aiter__()  # aiter() builtin is 3.10+; python_requires is >=3.9
 
             def __getattr__(self_inner, item):
                 return getattr(ctx, item)

{agentx_python-0.8.19 → agentx_python-0.8.20}/agentx/integrations/autogen.py

@@ -167,6 +167,9 @@ class AgentXAutoGenObserver:
                         "end_time": end_t,
                         "input": pending["input"] if pending else None,
                         "output": f"ERROR: {output}" if is_error else (str(output) if output is not None else None),
+                        # The engine's failure test is success === false; without
+                        # this a failed tool call would read as passing.
+                        "success": not is_error,
                     })
                 continue
 

{agentx_python-0.8.19 → agentx_python-0.8.20}/agentx/integrations/crewai.py

@@ -127,6 +127,16 @@ class AgentXCrewObserver:
         except ImportError:
             return task_timings, lambda: None
 
+        # Double-instrumentation guard (bus-keyed latch, the same idea as the
+        # other integrations' _agentx_patched flag): the event bus is a global
+        # singleton, so a notebook re-run or an overlapping kickoff that
+        # already has AgentX listeners registered would otherwise get a second
+        # set and duplicate every task span. When already attached, this
+        # kickoff just falls back to the evenly-divided timing approximation.
+        if getattr(crewai_event_bus, "_agentx_attached", False):
+            return task_timings, lambda: None
+        crewai_event_bus._agentx_attached = True
+
         def on_task_started(source: Any, event: Any) -> None:
             task_id = getattr(event, "task_id", None)
             if task_id is None:
@@ -154,9 +164,14 @@ class AgentXCrewObserver:
         crewai_event_bus.on(TaskFailedEvent)(on_task_failed)
 
         def unregister() -> None:
-            crewai_event_bus.off(TaskStartedEvent, on_task_started)
-            crewai_event_bus.off(TaskCompletedEvent, on_task_completed)
-            crewai_event_bus.off(TaskFailedEvent, on_task_failed)
+            try:
+                crewai_event_bus.off(TaskStartedEvent, on_task_started)
+                crewai_event_bus.off(TaskCompletedEvent, on_task_completed)
+                crewai_event_bus.off(TaskFailedEvent, on_task_failed)
+            finally:
+                # Clear the latch even if .off() raises, so a later kickoff
+                # can re-attach instead of being locked out forever.
+                crewai_event_bus._agentx_attached = False
 
         return task_timings, unregister
 

{agentx_python-0.8.19 → agentx_python-0.8.20}/agentx/integrations/langchain.py

@@ -339,6 +339,16 @@ class AgentXCallbackHandler(BaseCallbackHandler):
             self._retrieval_starts.pop(run_id, None)
             self._parents.pop(run_id, None)
 
+        # Pre-run retrieval steps waiting for a top-level chain that never came
+        # (e.g. retriever.invoke() called but agent.invoke() aborted before
+        # on_chain_start). Each step carries its own start_time, so drop the
+        # pre-cutoff ones just like the run_id-keyed structures above.
+        with self._state_lock:
+            if self._pending_retrieval_steps:
+                self._pending_retrieval_steps[:] = [
+                    step for step in self._pending_retrieval_steps if step.get("start_time", 0) >= cutoff
+                ]
+
     # ------------------------------------------------------------------
     # Chain lifecycle
     # ------------------------------------------------------------------
@@ -359,8 +369,9 @@ class AgentXCallbackHandler(BaseCallbackHandler):
             self._prune_stale_entries()
             # Consume any retrieval steps that ran before this chain started
             # (pre-run RAG: retriever.invoke() called before agent.invoke())
-            pending = self._pending_retrieval_steps[:]
-            self._pending_retrieval_steps.clear()
+            with self._state_lock:
+                pending = self._pending_retrieval_steps[:]
+                self._pending_retrieval_steps.clear()
             self._runs[run_id] = {
                 "start": time.time(),
                 "input": _extract_input(inputs),
@@ -670,7 +681,7 @@ class AgentXCallbackHandler(BaseCallbackHandler):
             "input": _extract_llm_input(prompts=prompts, messages=messages),
         }
         top = self._find_top_ancestor(parent_run_id)
-        if top and not self._runs[top].get("model") and model:
+        if top and top in self._runs and not self._runs[top].get("model") and model:
             self._runs[top]["model"] = model
 
     def on_llm_start(
@@ -882,15 +893,16 @@ class AgentXCallbackHandler(BaseCallbackHandler):
                 step["output"] = "\n\n---\n\n".join(contents)
 
         top = self._find_top_ancestor(parent_run_id)
-        if top and top in self._runs:
-            # Retriever ran inside an active chain - attach directly
-            retrievals = self._runs[top]["retrieval_steps"]
-            step["name"] = f"Retrieval {len(retrievals) + 1}"
-            retrievals.append(step)
-        else:
-            # Retriever ran before the chain started (pre-run RAG pattern)
-            step["name"] = f"Retrieval {len(self._pending_retrieval_steps) + 1}"
-            self._pending_retrieval_steps.append(step)
+        with self._state_lock:
+            if top and top in self._runs:
+                # Retriever ran inside an active chain - attach directly
+                retrievals = self._runs[top]["retrieval_steps"]
+                step["name"] = f"Retrieval {len(retrievals) + 1}"
+                retrievals.append(step)
+            else:
+                # Retriever ran before the chain started (pre-run RAG pattern)
+                step["name"] = f"Retrieval {len(self._pending_retrieval_steps) + 1}"
+                self._pending_retrieval_steps.append(step)
 
     def on_retriever_error(
         self,
@@ -918,15 +930,16 @@ class AgentXCallbackHandler(BaseCallbackHandler):
             step["query"] = query
 
         top = self._find_top_ancestor(parent_run_id)
-        if top and top in self._runs:
-            # Retriever ran inside an active chain - attach directly
-            retrievals = self._runs[top]["retrieval_steps"]
-            step["name"] = f"Retrieval {len(retrievals) + 1}"
-            retrievals.append(step)
-        else:
-            # Retriever ran before the chain started (pre-run RAG pattern)
-            step["name"] = f"Retrieval {len(self._pending_retrieval_steps) + 1}"
-            self._pending_retrieval_steps.append(step)
+        with self._state_lock:
+            if top and top in self._runs:
+                # Retriever ran inside an active chain - attach directly
+                retrievals = self._runs[top]["retrieval_steps"]
+                step["name"] = f"Retrieval {len(retrievals) + 1}"
+                retrievals.append(step)
+            else:
+                # Retriever ran before the chain started (pre-run RAG pattern)
+                step["name"] = f"Retrieval {len(self._pending_retrieval_steps) + 1}"
+                self._pending_retrieval_steps.append(step)
 
     # ------------------------------------------------------------------
     # Helpers

{agentx_python-0.8.19 → agentx_python-0.8.20}/agentx/integrations/llamaindex.py

@@ -107,18 +107,51 @@ class AgentXLlamaIndexHandler(BaseCallbackHandler):
         name: str = "llamaindex-agent",
         metadata: Optional[Dict[str, Any]] = None,
         session_id: Optional[str] = None,
+        max_run_age_seconds: float = 900.0,
     ) -> None:
         super().__init__(event_starts_to_ignore=[], event_ends_to_ignore=[])
         self._tracer = tracer
         self._name = name
         self._metadata = metadata
         self._session_id = session_id
+        # Safety net mirroring langchain.py's _prune_stale_entries: state is
+        # normally popped in on_event_end, but an event whose end callback never
+        # fires (hard crash, integration bug) would leak forever in this
+        # long-lived singleton handler. Entries older than this are swept out
+        # at the top of on_event_start.
+        self._max_run_age_seconds = max_run_age_seconds
 
         self._parents: Dict[str, Optional[str]] = {}
         self._roots: Dict[str, bool] = {}
         self._runs: Dict[str, Dict[str, Any]] = {}
         self._starts: Dict[str, Dict[str, Any]] = {}
 
+    def _prune_stale_entries(self) -> None:
+        """Sweep out event_id entries older than max_run_age_seconds - see __init__'s comment."""
+        cutoff = time.time() - self._max_run_age_seconds
+
+        # Every live event_id has a _starts entry (set in on_event_start and
+        # popped with _parents/_roots in on_event_end), each carrying its own
+        # start timestamp.
+        stale_event_ids = [
+            event_id for event_id, info in self._starts.items() if info.get("start", 0) < cutoff
+        ]
+        for event_id in stale_event_ids:
+            self._starts.pop(event_id, None)
+            self._parents.pop(event_id, None)
+            self._roots.pop(event_id, None)
+            self._runs.pop(event_id, None)
+
+        # Root runs outlive their own _starts entry until the root's end event
+        # fires - sweep those by the run state's own start timestamp.
+        stale_run_ids = [
+            event_id for event_id, state in self._runs.items() if state.get("start", 0) < cutoff
+        ]
+        for event_id in stale_run_ids:
+            self._runs.pop(event_id, None)
+            self._roots.pop(event_id, None)
+            self._parents.pop(event_id, None)
+
     # ------------------------------------------------------------------
     # BaseCallbackHandler protocol
     # ------------------------------------------------------------------
@@ -138,6 +171,7 @@ class AgentXLlamaIndexHandler(BaseCallbackHandler):
         **kwargs: Any,
     ) -> str:
         payload = payload or {}
+        self._prune_stale_entries()
         self._parents[event_id] = parent_id
 
         root_id = self._find_root(parent_id)
@@ -251,11 +285,16 @@ class AgentXLlamaIndexHandler(BaseCallbackHandler):
             tool_output = payload.get(EventPayload.FUNCTION_OUTPUT)
             state["tool_call_steps"].append({
                 "name": tool_name,
-                "duration_ms": (end_t - start_t) * 1000,
+                # tracer._merge_child_run's tool_calls loop reads "latency_ms"
+                # (not "duration_ms" like execution/retrieval steps).
+                "latency_ms": int((end_t - start_t) * 1000),
                 "start_time": start_t,
                 "end_time": end_t,
                 "input": _safe_serialize(tool_input) if tool_input is not None else None,
                 "output": f"ERROR: {exception}" if exception else (str(tool_output) if tool_output is not None else None),
+                # The engine's failure test is success === false; without this a
+                # failed tool call would read as passing.
+                "success": exception is None,
             })
 
         if is_root:
@@ -277,10 +316,9 @@ class AgentXLlamaIndexHandler(BaseCallbackHandler):
         return None
 
     def _send_trace(self, state: Dict[str, Any]) -> None:
-        # tool_call_steps entries carry start_time/end_time (unlike langchain.py's leaner
-        # wire-shaped tool_calls list) - _merge_child_run's tool_calls loop falls back to
-        # computing duration from those when no explicit latency_ms is present, so each tool
-        # call still positions correctly in the tree panel instead of defaulting to offset 0.
+        # tool_call_steps entries carry latency_ms AND start_time/end_time - _merge_child_run's
+        # tool_calls loop reads latency_ms for duration and the timestamps for position, so each
+        # tool call lands correctly in the tree panel instead of defaulting to offset 0.
         with self._tracer.trace(
             self._name, metadata=self._metadata, session_id=self._session_id, framework="llamaindex"
         ) as span:

{agentx_python-0.8.19 → agentx_python-0.8.20}/agentx/integrations/openai_agents.py

@@ -16,6 +16,8 @@ Requires: ``pip install "agentx-python[openai-agents]"``
 from __future__ import annotations
 
 from datetime import datetime, timezone
+import time
+from uuid import uuid4
 from typing import Any, Dict, List, Optional
 
 from agentx.tracing.tracer import Tracer, _safe_serialize
@@ -145,7 +147,15 @@ class AgentXTracingProcessor:
             metadata=self._metadata,
             session_id=self._session_id,
         )
-        root_span.__enter__()
+        # Deliberately NOT root_span.__enter__(): enter pushes onto the CALLING thread's
+        # active-span stack, but the Agents SDK fires on_trace_end on whatever thread it
+        # likes - the pop then no-ops there, the entry never drains, and every later
+        # unrelated trace on this thread is mis-filed as a child of this dead run (and
+        # inherits its session). Start time and session are set by hand instead; on_span_end
+        # already parents via child_span() on this exact reference, no stack involved.
+        root_span._start = time.time()
+        if root_span._session_id is None:
+            root_span._session_id = f"sdk_{uuid4().hex}"
         self._spans[trace_id] = {
             "root_span": root_span,
             "llm_call_count": 0,
@@ -173,6 +183,9 @@ class AgentXTracingProcessor:
         root_span._output_tokens = state["output_tokens"]
         if state.get("error"):
             root_span.set_error(state["error"])
+        # Close WITHOUT touching the thread-local stack (see on_trace_start). __exit__'s only
+        # stack interaction is the pop, which is a no-op for a never-pushed span - safe to call
+        # directly for its send/flush behavior.
         root_span.__exit__(None, None, None)
 
     def on_span_start(self, span: Any) -> None:

{agentx_python-0.8.19 → agentx_python-0.8.20}/agentx/monitor/client.py

@@ -28,7 +28,12 @@ _RETRY_BACKOFF = [1.0, 2.0, 4.0]
 
 
 class AgentXMonitorError(Exception):
-    pass
+    """``status_code`` carries the HTTP status when the error came from a server
+    response; it is ``None`` for transport-level failures and retry exhaustion."""
+
+    def __init__(self, message: str, status_code: Optional[int] = None) -> None:
+        super().__init__(message)
+        self.status_code = status_code
 
 
 class AgentXAuthError(AgentXMonitorError):
@@ -208,17 +213,17 @@ class MonitorClient:
                 continue
 
             if resp.status_code == 401:
-                raise AgentXAuthError("Invalid or missing API key")
+                raise AgentXAuthError("Invalid or missing API key", status_code=401)
             if resp.status_code == 422:
-                raise AgentXValidationError(resp.text)
+                raise AgentXValidationError(resp.text, status_code=422)
             if retry and resp.status_code in _RETRYABLE_STATUS and attempt < _MAX_RETRIES - 1:
                 logger.debug(
                     "Retryable status %d (attempt %d)", resp.status_code, attempt + 1
                 )
-                last_exc = AgentXMonitorError(f"HTTP {resp.status_code}")
+                last_exc = AgentXMonitorError(f"HTTP {resp.status_code}", status_code=resp.status_code)
                 continue
             if not resp.ok:
-                raise AgentXMonitorError(f"HTTP {resp.status_code}: {resp.text}")
+                raise AgentXMonitorError(f"HTTP {resp.status_code}: {resp.text}", status_code=resp.status_code)
             try:
                 return resp.json()
             except Exception:
@@ -481,7 +486,7 @@ class MonitorClient:
     def propose_online_evaluator_tuning(self, evaluator_id: str, window: str = "7d") -> dict:
         data = self._request(
             "POST", f"/agent-monitoring/online-evaluators/{evaluator_id}/tune",
-            base=self._api_root(), json={"window": window}, timeout=300,
+            base=self._api_root(), json={"window": window}, timeout=300, retry=False,
         )
         return data.get("proposal", data) if isinstance(data, dict) else data
 
@@ -490,7 +495,7 @@ class MonitorClient:
     ) -> dict:
         return self._request(
             "POST", f"/agent-monitoring/online-evaluators/{evaluator_id}/tune/validate",
-            base=self._api_root(), json={**criteria, "window": window}, timeout=600,
+            base=self._api_root(), json={**criteria, "window": window}, timeout=600, retry=False,
         )
 
     def publish_online_evaluator_tuning(
@@ -505,7 +510,7 @@ class MonitorClient:
             payload["force"] = True
         return self._request(
             "POST", f"/agent-monitoring/online-evaluators/{evaluator_id}/tune/publish",
-            base=self._api_root(), json=payload, timeout=60,
+            base=self._api_root(), json=payload, timeout=60, retry=False,
         )
 
     def update_profile(self, agent_id: str, payload: dict) -> MonitorProfile:

{agentx_python-0.8.19 → agentx_python-0.8.20}/agentx/monitor/scorer_groups.py

@@ -49,7 +49,8 @@ class ScorerGroupsClient:
         )
         if response.status_code >= 400:
             raise AgentXScorerGroupsError(f"HTTP {response.status_code}: {response.text}")
-        return response.json()
+        # DELETE (and any other empty 2xx) has no body - .json() on it raises.
+        return response.json() if response.text else {}
 
     def list(self) -> List[ScorerGroup]:
         return [ScorerGroup(g) for g in self._request("GET", self._base).get("scorerGroups", [])]

{agentx_python-0.8.19 → agentx_python-0.8.20}/agentx/monitor/scorers.py

@@ -65,11 +65,18 @@ class ScorersClient:
         return [p for p in patterns if p.get("source") == "builtIn"]
 
     def _enabled_template_keys(self) -> List[str]:
-        return [p["key"] for p in self.templates() if p.get("enabled")]
+        # .get("key"): defensive against a template row missing its key (the wire owns this
+        # shape, not the SDK) - a keyless row is skipped rather than KeyError-ing the sweep.
+        return [p.get("key") for p in self.templates() if p.get("enabled") and p.get("key")]
 
     def enable(self, keys: Sequence[str]) -> List[str]:
         """Enable template scorers by key (e.g. ``["pii-in-response"]``), preserving what is
-        already on. Returns the resulting enabled-key list."""
+        already on. Returns the resulting enabled-key list.
+
+        Note: enable()/disable() are a read-modify-write over the project's single
+        enabledBuiltinPatterns list - two concurrent callers (or a dashboard edit racing an
+        SDK call) can lose one side's change. There is no engine-side merge; serialize
+        catalog edits if that matters."""
         merged = sorted(set(self._enabled_template_keys()) | set(keys))
         self._request("PUT", "/settings/monitoring-defaults", json={"enabledBuiltinPatterns": merged})
         return merged

{agentx_python-0.8.19 → agentx_python-0.8.20}/agentx/monitor/sessions.py

@@ -27,8 +27,24 @@ class MonitorSessionClient:
         Baseline Judge existed - branch defensively on unknown kinds."""
         return self._client.list_session_scores(session_id)
 
+    def judge(self, session_id: str, evaluator_id: str, *, if_stale: bool = False) -> dict:
+        """Judge one session with one session-scoped evaluator, now (one judge call).
+        ``if_stale=True`` skips re-judging a session that was already scored since its
+        last activity - the engine then answers ``{"skipped": True}`` without spending
+        another judge call. Returns the score row (or that skip marker)."""
+        data = self._client._request(
+            "POST",
+            f"/agent-monitoring/sessions/{session_id}/judge/{evaluator_id}",
+            base=self._client._api_root(),
+            timeout=120,
+            retry=False,
+            params={"ifStale": "true"} if if_stale else None,
+        )
+        return data.get("score", data) if isinstance(data, dict) else data
+
     def run_sweep(self) -> dict:
         """Trigger the idle-session sweep once (normally automatic, every minute) - scores
         idle multi-turn sessions with every enabled session-scoped evaluator and scorer
-        group. Returns ``{"judged": n}``."""
+        group. Returns ``{"judged": n}``; the response may instead carry ``skipped: true``
+        when another sweep is already in flight."""
         return self._client.run_session_sweep()