agentx-python 0.8.18__py3-none-any.whl → 0.8.20__py3-none-any.whl

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/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/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/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/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/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/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/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/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/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/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/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/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/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/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()

agentx/tracing/ci_types.py

@@ -1,14 +1,20 @@
-"""Dataclasses for CI/CD evaluation run responses."""
+"""Dataclasses for CI/CD evaluation run responses.
+
+Annotations deliberately use typing.Optional/List (not PEP 604/585 syntax):
+``from __future__ import annotations`` only defers evaluation, and
+``typing.get_type_hints`` on these classes still has to resolve the strings
+at runtime, which fails for ``str | None`` / ``list[...]`` on Python 3.9.
+"""
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import Any, Literal
+from typing import Any, Dict, List, Literal, Optional
 
 
 @dataclass
 class CITestCase:
     index: int
-    query: str | None = None  # None when ci.exposeTestInputs is false
+    query: Optional[str] = None  # None when ci.exposeTestInputs is false
 
 
 @dataclass
@@ -16,7 +22,7 @@ class CIRun:
     run_id: str
     dataset_id: str
     total_questions: int
-    test_cases: list[CITestCase]
+    test_cases: List[CITestCase]
     expires_at: str
 
 
@@ -47,20 +53,20 @@ class CIRunResult:
     pass_rate: float
     total_questions: int
     passed_questions: int
-    scores: list[CIQuestionScore] = field(default_factory=list)
-    violations: list[ThresholdViolation] = field(default_factory=list)
-    git_context: dict | None = None
-    finalized_at: str | None = None
+    scores: List[CIQuestionScore] = field(default_factory=list)
+    violations: List[ThresholdViolation] = field(default_factory=list)
+    git_context: Optional[Dict[str, Any]] = None
+    finalized_at: Optional[str] = None
 
 
 @dataclass
 class CIRunStatus:
     run_id: str
     status: Literal["in_progress", "completed", "failed"]
-    gate: Literal["pass", "fail"] | None
+    gate: Optional[Literal["pass", "fail"]]
     results_submitted: int
     total_questions: int
     created_at: str
     expires_at: str
-    finalized_at: str | None = None
-    git_context: dict | None = None
+    finalized_at: Optional[str] = None
+    git_context: Optional[Dict[str, Any]] = None

agentx/tracing/ingest_client.py

@@ -138,27 +138,42 @@ class IngestClient:
         """
         Send a trace payload synchronously and return the ingested trace's id, or ``None`` on
         failure. Used by ``Tracer.trace(..., sync=True)`` when the caller needs the trace_id back
-        immediately (e.g. to attach it to an evaluation result) - unlike ``enqueue()``, this blocks
-        and does not retry, trading the tracer's usual fire-and-forget guarantee for a same-call
-        result. Never raises; a failed send just means no trace_id (never blocks the caller's eval
-        run over a tracing hiccup).
+        immediately (e.g. to attach it to an evaluation result) - unlike ``enqueue()``, this
+        blocks, trading the tracer's usual fire-and-forget guarantee for a same-call result.
+        A 429/503 (engine shedding load or briefly unavailable) is retried up to 2 times,
+        honoring the server's Retry-After (capped at 5s per wait) - span ids make redelivery
+        idempotent server-side, so a retry can never double-ingest. Never raises; ``None``
+        means the trace was NOT stored (there is no local persistence or background retry
+        beyond those brief attempts), so no trace_id exists for it.
         """
         if self._workspace_id:
             payload = {**payload, "workspaceId": self._workspace_id}
-        try:
-            resp = self._session.post(self._endpoint, json=payload, timeout=10)
-        except requests.RequestException as exc:
-            self._warn_delivery(f"{exc.__class__.__name__}: {exc}")
-            logger.debug("agentx ingest sync send error: %s", exc)
-            return None
-        if not resp.ok:
-            self._warn_delivery(f"HTTP {resp.status_code}", status=resp.status_code)
-            logger.debug("agentx ingest sync HTTP %d: %s", resp.status_code, resp.text[:200])
-            return None
-        try:
-            return resp.json().get("trace_id")
-        except Exception:
-            return None
+        for attempt in range(3):  # 1 try + up to 2 bounded retries on 429/503
+            try:
+                resp = self._session.post(self._endpoint, json=payload, timeout=10)
+            except requests.RequestException as exc:
+                self._warn_delivery(f"{exc.__class__.__name__}: {exc}")
+                logger.debug("agentx ingest sync send error: %s", exc)
+                return None
+            if resp.status_code in (429, 503) and attempt < 2:
+                retry_after = resp.headers.get("Retry-After")
+                wait = 1.0
+                if retry_after:
+                    try:
+                        wait = min(5.0, float(retry_after))
+                    except ValueError:
+                        pass
+                time.sleep(wait)
+                continue
+            if not resp.ok:
+                self._warn_delivery(f"HTTP {resp.status_code}", status=resp.status_code)
+                logger.debug("agentx ingest sync HTTP %d: %s", resp.status_code, resp.text[:200])
+                return None
+            try:
+                return resp.json().get("trace_id")
+            except Exception:
+                return None
+        return None  # pragma: no cover - loop always returns
 
     def send_trace_sync_detailed(self, payload: Dict[str, Any]) -> Optional[Dict[str, Any]]:
         """``send_trace_sync`` returning the full response body instead of just the id - the
@@ -418,16 +433,22 @@ class IngestClient:
 
     def _send(self, payload: Dict[str, Any]) -> None:
         last_exc: Optional[Exception] = None
-        for attempt, wait in enumerate([0.0] + _RETRY_BACKOFF):
-            if wait:
+        schedule = [0.0] + _RETRY_BACKOFF
+        skip_next_wait = False
+        for attempt, wait in enumerate(schedule):
+            if wait and not skip_next_wait:
                 time.sleep(wait)
+            skip_next_wait = False
             try:
                 resp = self._session.post(self._endpoint, json=payload, timeout=10)
             except requests.RequestException as exc:
                 last_exc = exc
                 continue
 
-            if resp.status_code in _RETRYABLE_STATUS and attempt < _MAX_RETRIES - 1:
+            # Gate on the schedule itself so HTTP-status retries walk the SAME full backoff
+            # schedule connection errors do (the old `attempt < _MAX_RETRIES - 1` gate left the
+            # schedule's last backoff entry unreachable for HTTP retries).
+            if resp.status_code in _RETRYABLE_STATUS and attempt < len(schedule) - 1:
                 # 429 = the engine's bounded ingest queue shedding load (its ADR-0005): honor
                 # Retry-After exactly instead of the generic backoff schedule, so the SDK backs
                 # off in step with the server's own flush cadence.
@@ -435,6 +456,9 @@ class IngestClient:
                 if resp.status_code == 429 and retry_after:
                     try:
                         time.sleep(min(30.0, float(retry_after)))
+                        # Retry-After REPLACES the schedule's next wait - sleeping both would
+                        # back off longer than either the server or the schedule asked for.
+                        skip_next_wait = True
                     except ValueError:
                         pass
                 last_exc = Exception(f"HTTP {resp.status_code}")
@@ -442,6 +466,9 @@ class IngestClient:
             if not resp.ok:
                 self._warn_delivery(f"HTTP {resp.status_code}", status=resp.status_code)
                 logger.debug("agentx ingest HTTP %d: %s", resp.status_code, resp.text[:200])
+                # Non-retryable failure still cost us this payload - never drop silently
+                # (same rule _drain and the retries-exhausted path below follow).
+                self._record_drop(f"HTTP {resp.status_code}")
                 return
             return
 

agentx/tracing/tracer.py

@@ -4,6 +4,7 @@ import asyncio
 import concurrent.futures
 import functools
 import inspect
+import contextvars
 import threading
 import time
 from contextlib import contextmanager
@@ -70,7 +71,7 @@ class _TraceSpan:
         model: Optional[str] = None,
         session_id: Optional[str] = None,
         sync: bool = False,
-        monitor: bool = False,
+        monitor: Optional[bool] = None,
         pattern_ids: Optional[List[str]] = None,
         agent_id: Optional[str] = None,
         span_kind: Optional[str] = None,
@@ -104,6 +105,11 @@ class _TraceSpan:
         # __enter__/_merge_child_run/child_span.
         self._span_id = uuid4().hex
         self._parent_span_id: Optional[str] = None
+        # Set on first __enter__ - a re-entered span object regenerates its
+        # span_id there so each `with span:` re-use sends a fresh identity
+        # (the server dedupes on span_id, so a reused id would silently
+        # collapse the second run into the first).
+        self._entered = False
         # Numbers auto-named "LLM Call N"/"Retrieval N" child spans - see _merge_child_run.
         self._child_span_count = 0
         # Monitor: True checks this trace against patterns immediately on ingest, no dashboard
@@ -145,6 +151,13 @@ class _TraceSpan:
     # ------------------------------------------------------------------
 
     def __enter__(self) -> "_TraceSpan":
+        if self._entered:
+            # Re-using one span object for another `with` block: regenerate the
+            # identity so this run sends its own span row instead of being
+            # deduped server-side against the first entry's span_id.
+            self._span_id = uuid4().hex
+            self._trace_id = None
+        self._entered = True
         self._start = time.time()
         # Resolve real span hierarchy against whatever's currently active on this thread, before
         # pushing self (so `parent` here is the actual enclosing span, not self).
@@ -581,6 +594,14 @@ class _RetrievalRecorder:
         self.output: Any = None
 
 
+class _MemoryOpRecorder:
+    """Handle yielded by ``Tracer.trace_memory()`` - set ``output`` (what was recalled or
+    stored) inside the block."""
+
+    def __init__(self) -> None:
+        self.output: Any = None
+
+
 class _ToolCallRecorder:
     """Handle yielded by ``Tracer.trace_tool_call()`` - set ``output`` inside the block.
     ``success``/``error`` may be set manually; an exception escaping the block sets them
@@ -619,36 +640,39 @@ class Tracer:
         self._client = ingest_client
         self._pending_tool_calls: List[Dict[str, Any]] = []
         self._pending_retrievals: List[Dict[str, Any]] = []
-        self._local = threading.local()
+        # Context-local, not thread-local: two coroutines interleaving on one event loop each
+        # get their own asyncio task Context, so concurrent `async def` agents no longer
+        # mis-parent each other's spans (a thread-local stack merged them into one fabricated
+        # tree). Bare threads keep the old behavior - each starts an empty Context. Stored
+        # immutably (tuple, copy-on-write) so a child task's pushes never leak into siblings.
+        self._span_stack_var: "contextvars.ContextVar[tuple]" = contextvars.ContextVar(
+            f"agentx_span_stack_{id(self)}", default=()
+        )
 
     # ------------------------------------------------------------------
-    # Active-span stack (per thread) - lets auto-instrumented integrations
+    # Active-span stack (per context) - lets auto-instrumented integrations
     # (e.g. patch_anthropic_client) detect they're running inside a
     # `with tracer.trace(...)` block and attach to it as an LLM-call step
     # instead of sending their own independent trace.
     # ------------------------------------------------------------------
 
-    def _get_span_stack(self) -> List["_TraceSpan"]:
-        stack = getattr(self._local, "span_stack", None)
-        if stack is None:
-            stack = []
-            self._local.span_stack = stack
-        return stack
+    def _get_span_stack(self) -> tuple:
+        return self._span_stack_var.get()
 
     def _push_active_span(self, span: "_TraceSpan") -> None:
-        self._get_span_stack().append(span)
+        self._span_stack_var.set(self._span_stack_var.get() + (span,))
 
     def _pop_active_span(self, span: "_TraceSpan") -> None:
-        stack = self._get_span_stack()
+        stack = self._span_stack_var.get()
         if stack and stack[-1] is span:
-            stack.pop()
+            self._span_stack_var.set(stack[:-1])
         elif span in stack:
-            stack.remove(span)
+            self._span_stack_var.set(tuple(item for item in stack if item is not span))
 
     @property
     def current_span(self) -> Optional["_TraceSpan"]:
-        """The innermost ``with tracer.trace(...)`` span active on this thread, if any."""
-        stack = self._get_span_stack()
+        """The innermost ``with tracer.trace(...)`` span active in this context, if any."""
+        stack = self._span_stack_var.get()
         return stack[-1] if stack else None
 
     @contextmanager
@@ -832,6 +856,92 @@ class Tracer:
             span_kind="retrieval",
         )
 
+    def record_memory(
+        self,
+        name: str = "Memory",
+        *,
+        operation: Optional[str] = None,
+        query: Optional[str] = None,
+        output: Any = None,
+        duration_ms: Optional[float] = None,
+        start_time: Optional[float] = None,
+        end_time: Optional[float] = None,
+    ) -> None:
+        """
+        Manually record a long-term-memory operation (a Mem0/Zep/Letta-style recall or store)
+        as a ``span_kind="memory"`` child span of the active span. ``operation`` is free text -
+        conventionally ``"read"`` or ``"write"`` - carried in the span's metadata; the kind
+        itself stays one value so dashboards and scorers can select all memory activity at once.
+        Deliberately NOT a retrieval: retrieval spans feed the RAG judges' ``{context}``
+        (knowledge grounding), while memory is recalled state - see the engine's spanKind.ts.
+        """
+        active_span = self.current_span
+        if active_span is None:
+            # Same posture as record_retrieval: queue and merge into the next trace this
+            # tracer sends (the patched-client flow where the memory op runs just before a
+            # standalone completions call) instead of silently dropping the record.
+            latency_ms = (
+                int(duration_ms)
+                if duration_ms is not None
+                else int((end_time - start_time) * 1000)
+                if start_time is not None and end_time is not None
+                else None
+            )
+            self._pending_retrievals.append({
+                "name": name,
+                "query": _safe_serialize(query) if query is not None else None,
+                "output": _safe_serialize(output) if output is not None else None,
+                "duration_ms": latency_ms,
+                "kind": "memory",
+                **({"operation": operation} if operation else {}),
+            })
+            return
+        active_span.child_span(
+            name,
+            start_time=start_time,
+            end_time=end_time,
+            duration_ms=duration_ms,
+            input=query,
+            output=output,
+            metadata={"kind": "memory", **({"operation": operation} if operation else {})},
+            span_kind="memory",
+        )
+
+    @contextmanager
+    def trace_memory(
+        self, name: str = "Memory", *, operation: Optional[str] = None, query: Optional[str] = None
+    ) -> Iterator["_MemoryOpRecorder"]:
+        """
+        Context manager that times a memory operation and records it via
+        :meth:`record_memory` on exit::
+
+            with tracer.trace_memory("user prefs", operation="read", query=user_id) as m:
+                m.output = memory.search(user_id, question)
+        """
+        start_t = time.time()
+        recorder = _MemoryOpRecorder()
+        error: Optional[str] = None
+        try:
+            yield recorder
+        except Exception as exc:
+            # A memory op that raised must not be recorded as a clean span (trace_tool_call
+            # precedent) - fold the error into the output and re-raise.
+            error = str(exc)
+            raise
+        finally:
+            end_t = time.time()
+            if error is not None and recorder.output is None:
+                recorder.output = f"ERROR: {error}"
+            self.record_memory(
+                name,
+                operation=operation,
+                query=query,
+                output=recorder.output,
+                duration_ms=(end_t - start_t) * 1000,
+                start_time=start_t,
+                end_time=end_t,
+            )
+
     @contextmanager
     def trace_retrieval(self, name: str = "Retrieval", *, query: Optional[str] = None) -> Iterator["_RetrievalRecorder"]:
         """

agentx/version.py

@@ -1,7 +1,7 @@
-VERSION = "0.8.18"
+VERSION = "0.8.20"
 
 # 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.18"
+ENGINE_VERSION = "v0.3.21"

{agentx_python-0.8.18.dist-info → agentx_python-0.8.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentx-python
-Version: 0.8.18
+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.18.dist-info → agentx_python-0.8.20.dist-info}/RECORD

@@ -1,4 +1,4 @@
-agentx/__init__.py,sha256=4iMiGLNU4S-I-WyX0Z7l0BFUY_krVJ3seMQPqyO-ReA,602
+agentx/__init__.py,sha256=k-89JLBl_jNXhVCtBbdtlDUGA1nLcDblvd7adk7Y3S8,790
 agentx/agentx.py,sha256=WuzVQtXSPqBhRwKxkUlQ8VG2cwvGpbMcti4n6aTNPwA,8816
 agentx/cli.py,sha256=yawLQLSeZ7KIl7ukgmly-lrYbx9GgKcaI9M4xamiMPw,10468
 agentx/exceptions.py,sha256=2tDLdZjriFBQbjgzyIcah12RazpbujhqZSRbSXgAml4,1377
@@ -10,17 +10,17 @@ agentx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 agentx/testing.py,sha256=0shZEid_vhJgBegpO_loUq6APYDxQrUgD3jvcRdIDV8,7372
 agentx/traces.py,sha256=sz9gxutlDKNgf0fdCkyzKsGwK5eMAJuIEl3NIwGrsuo,2287
 agentx/util.py,sha256=lt2Kpg4Fj8whrSuAhLEahcPEIYRVpK9RCC5y9ShdTJs,703
-agentx/version.py,sha256=12ZEc4OJ-zU1rtsHoDBC5wqnwX7BmZ9OmiL3F4NWnMQ,366
+agentx/version.py,sha256=vPqx2---hI57dDK8pRv2qIEkiaUleIQleNKmcs_kTw4,366
 agentx/evaluations/__init__.py,sha256=Erv7RGFlRxGTG4rVb2uHhCqLLEX_iAWKqkZKzK6CumE,262
 agentx/evaluations/_term.py,sha256=WFpiNzdgDBeJJ-Gg-6X7TwwxllobuE4OqFUTuDQvS3Y,2529
-agentx/evaluations/client.py,sha256=f5GqsiuqknE-ENUYocBcXgV6OGMKdzmlsm76takJbwU,33112
-agentx/evaluations/datasets.py,sha256=DuX-wu5Kz953s6-605lt8N8-kn3F4WuwaCMq5ISZwbA,16051
+agentx/evaluations/client.py,sha256=JPH4CAkPWz2S-8bnxoqAcB0T6Ml70tg6JUxf_ZyTHLM,34269
+agentx/evaluations/datasets.py,sha256=YhwGMZkDqxfR-0e81o9WrQAq_Bc1BYclizh2ka1kBi0,16759
 agentx/evaluations/evaluation_settings.py,sha256=PhZtflmEAw33EHuzu4C_Vpm8BBjnIPw60y7VEJ7mU8s,6274
 agentx/evaluations/models.py,sha256=v-t6_HkEQlGNc7ZGfoYXZ7FrFjepuyRODkly-ce6Qjw,32936
 agentx/evaluations/prompts.py,sha256=8xyvMpAl3mD5xuSZozuaohdnCBWe5Q02RldwiPLUO20,3493
-agentx/evaluations/reporting.py,sha256=GtNnL-1eNEQrSqd0yrHi5mGqC9_u0kUAN8Mbjdhw6yY,6389
+agentx/evaluations/reporting.py,sha256=RPeVBdfynQhkvk4KiOh6I-DqWFLfSrEniW3dWWTiW5I,6424
 agentx/evaluations/results.py,sha256=w7TRUik4eXIqrznXvlF_L9hnObnHvgdRKvihfN1XeAU,4692
-agentx/evaluations/runner.py,sha256=2lxbYKTE2OVH_DFq5yVdAH6cvW5rf3rL91VlEepWLiQ,34714
+agentx/evaluations/runner.py,sha256=_P0ZyvR6k620jgKzv8JXDTklb9zXDv-qGF4KUug4RyA,35114
 agentx/evaluations/tool_schemas.py,sha256=ZyrnSOnx9xlSAj4swfDey9ZLS2ly-g21DByTwRAGwNA,2323
 agentx/evaluations/tracing.py,sha256=MSJD9bzfInMi7E70mc8mWUc0fx5DLkOgUzRru2mNQoc,1825
 agentx/evaluations/adapters/__init__.py,sha256=fK8Hx75usbiY03XUSmnLnSrwBXip2CQs24YZcdEgj6w,287
@@ -29,21 +29,21 @@ agentx/evaluations/adapters/precomputed.py,sha256=vxnQELmpiU2NkQATfiVjG7v1ZmmkrE
 agentx/evaluations/adapters/raw.py,sha256=FkDq_mdf21-xt5EHnGyIGcS6VZxkEkFcmM9VTd-T5sA,1130
 agentx/integrations/__init__.py,sha256=W-EcQhHE01-SGPeKTB2AgfvUyRzNP4BqUMMtP2qQ4Q0,647
 agentx/integrations/_traced_call.py,sha256=O6f8HKRHDfFwoUIZDtvENVsv_OsHwzuyPMbzBakKVdo,6662
-agentx/integrations/anthropic.py,sha256=Fdt1bVBKYuhUa8S4nsZLNqg4REUzaZsh-7RXEWuJ-0g,10392
-agentx/integrations/autogen.py,sha256=cZryUl45Sdr9t1ba4tkz45XfkvjCud1hPp6pV0auKy8,8863
-agentx/integrations/crewai.py,sha256=Ofid_YvIFYFoN12_gA3PjKAhlJgPNUh9sNyIbBcRkZs,10712
+agentx/integrations/anthropic.py,sha256=z6o9cC9rBzxxbF1UBiMr-kjEgDUO-BCuPOFoqGN3qF4,10451
+agentx/integrations/autogen.py,sha256=nl9XuhdBIajRmiz_DeXneqR-FtbslT0d9i1cZYKeJhA,9067
+agentx/integrations/crewai.py,sha256=EFQuRfj-5bwxNTefZDLF9cCUY8TomS2qg9T4SmjayQk,11586
 agentx/integrations/databricks.py,sha256=vKXnur-LWMTzctFuIKte2N826sydXVlpi1qFXo2dfio,18044
 agentx/integrations/google_adk.py,sha256=swLpAfkuL2m1VZUSf_3ImwsrcTSxVdS5EIKRu2Tf4R4,12476
 agentx/integrations/google_genai.py,sha256=2patIdgyjEEW70FLP7ng4hcnFY-p0a1jPi1Pof28KBo,13272
-agentx/integrations/langchain.py,sha256=z4esU-IjWuXS0Ft7PPGxnTBxBrrN7JmKEqW_1HpTdMI,38745
+agentx/integrations/langchain.py,sha256=IFfA7QddFPjK_JnFlruxrD-sCm5fgrY3VH_L4e4f3o0,39503
 agentx/integrations/litellm.py,sha256=F9Zcb58WtlBFsg_Ig1LGktpe99x9xXnYNi-C0UH54fI,6476
-agentx/integrations/llamaindex.py,sha256=pPw0N6VavIR25rrl6ZiUvb79hIPygfJgIxwr6kAvFqA,12777
+agentx/integrations/llamaindex.py,sha256=nG3EVauSAmHPpyzZkyc31HL3cnTKHQCK8ypK7ZpoQDE,14707
 agentx/integrations/moveworks.py,sha256=IyBswLE5LwMSp1VbIvG5izYV5BvXmv4atZelnrDn8SE,25670
 agentx/integrations/openai.py,sha256=1KLs-hJaeW2emHPwNkmC3zcGksL3zd87uWbcLGRW704,6644
-agentx/integrations/openai_agents.py,sha256=tCa3kPxqux5LnNNDQ6zA05OybQrjkc_LeE08YuNPJEs,12742
+agentx/integrations/openai_agents.py,sha256=9PIXFP3SuBJXc8f8ph7TBpoWoarfL265xRrYf0dgagc,13653
 agentx/monitor/__init__.py,sha256=MLiASSvQnCy2jqVNRTgPWFhUSf8lGYRQeEgEVVhE5Tg,574
 agentx/monitor/agents.py,sha256=8Xk4jWmNTvdtjFixHiLmw4jj96uqIXWIT6KW8zXoWrc,1006
-agentx/monitor/client.py,sha256=lQdTUsXcxZwUOhdxZ5X_GdlIGoAaZa55mwn2u9DmSaw,24008
+agentx/monitor/client.py,sha256=Q-VQbSO8AQZS5t0hzHxblp2I6xV3rOEEYLewlnr8vgQ,24451
 agentx/monitor/improvement_groups.py,sha256=-6-FcJnyiTLqeh9z8D9wyFD1QFqEsdDdDZdDJhC6QXw,3712
 agentx/monitor/judge_scorers.py,sha256=HKCPW_9QJeyGEGwWxr_clep9vn27bwJTKnjN5lYbuSk,15972
 agentx/monitor/models.py,sha256=yTC3WTdTziHMkdeAXlTro-4YiSbBUHMgf9kNZHGfPDA,8470
@@ -52,23 +52,23 @@ agentx/monitor/patterns.py,sha256=NFHmHJqbq_KC3hNjh9lgv5aB8rsyUovGdd9YGwsQKfE,44
 agentx/monitor/profile.py,sha256=uGk-4bXT2vmnEQiY5u6rWhAfzZchHBXL74VD3piVHvU,3102
 agentx/monitor/review_queue.py,sha256=Tr3GDMJLJzyFKEEeB8HPmZBsNzzYVJYElDlfBC4qd68,3766
 agentx/monitor/rules.py,sha256=oLQ5RPgMPUKJFTSZzcBEMLzDlICElUNJTyIqxZMAGmQ,3040
-agentx/monitor/scorer_groups.py,sha256=qff9eheOU7jMM8wVKU7gRrOlafPiQv16ieywBLAXFH0,3734
-agentx/monitor/scorers.py,sha256=huIZBszrfLKI8I7VV6NFpW6piRsj9HI03rXUwWs2tgs,7336
-agentx/monitor/sessions.py,sha256=EnhyMMe2muwLyuKn99mLw-Ff1tHTMsgM7H_SXob1ltY,1570
+agentx/monitor/scorer_groups.py,sha256=nye3v4Cs8qFS39sByiy0UbaOjdGPtVcoa8XC4vIDhZI,3838
+agentx/monitor/scorers.py,sha256=ZEJCoQNx5u78qf6T9MEAyG2yufJIzxIzEU8PnYxL0Co,7844
+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/tracing/__init__.py,sha256=l2mIRILE-wWrCD0fekgrIOQUEvtDObzdrkgpQUtXroU,408
-agentx/tracing/ci_types.py,sha256=zFVcZGvc1qbVDdOlEPQ1i5R6terqJHxCzFF4ZjouxxI,1423
+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=spnm6bV3NXGuj2w7HwdKiJdKDJWRUFmSP3jl3rcGqkQ,18202
-agentx/tracing/tracer.py,sha256=TxY6zG6hbM81jpfrqP4imaEvoyy_hnJVUSTnoAVHMG0,56240
-agentx_python-0.8.18.dist-info/licenses/LICENSE,sha256=gZVsM-nLsE8vlaY6NXXsVoo6IlCClxkToAWmhgT3y_s,10762
-agentx_python-0.8.18.dist-info/METADATA,sha256=P0yCj9IwWgJrN6c_YcDBWj5YZeJCFaBkz_CNv1mJ2p4,22117
-agentx_python-0.8.18.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-agentx_python-0.8.18.dist-info/entry_points.txt,sha256=rQqF1JTY3T1yfviBU1r8PU-5mBdfOk6P4bZ1L4BskIM,172
-agentx_python-0.8.18.dist-info/top_level.txt,sha256=s-q-HB9Gb_QdrZNacSeQyF_c25gQooMy7DlxzgLOHPk,7
-agentx_python-0.8.18.dist-info/RECORD,,
+agentx/tracing/ingest_client.py,sha256=9Gs_XEE-VJxcWdXjm6buo8wj5l7Pva1gX6AvtFOdzZs,19926
+agentx/tracing/tracer.py,sha256=iHQIR6XomOzYm9FvqSvu-hxM6Lg6mDXBMR8eTL-4ank,61289
+agentx_python-0.8.20.dist-info/licenses/LICENSE,sha256=gZVsM-nLsE8vlaY6NXXsVoo6IlCClxkToAWmhgT3y_s,10762
+agentx_python-0.8.20.dist-info/METADATA,sha256=_fBpNGWvcR0utTxdXRKZaFlhorOSqFXjSSim2KjW_Ro,22117
+agentx_python-0.8.20.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+agentx_python-0.8.20.dist-info/entry_points.txt,sha256=rQqF1JTY3T1yfviBU1r8PU-5mBdfOk6P4bZ1L4BskIM,172
+agentx_python-0.8.20.dist-info/top_level.txt,sha256=s-q-HB9Gb_QdrZNacSeQyF_c25gQooMy7DlxzgLOHPk,7
+agentx_python-0.8.20.dist-info/RECORD,,