agentx-python 0.8.22__tar.gz → 0.8.24__tar.gz

{agentx_python-0.8.22 → agentx_python-0.8.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentx-python
-Version: 0.8.22
+Version: 0.8.24
 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
@@ -255,6 +255,13 @@ extra:
 | LlamaIndex            | `pip install "agentx-python[llamaindex]"`    | `AgentXLlamaIndexHandler` |
 | AutoGen               | `pip install "agentx-python[autogen]"`       | `AgentXAutoGenObserver`   |
 
+> **Warning: pick ONE instrumentation layer per LLM call.** Do not combine
+> `AgentXCallbackHandler` (or any framework integration) with a patched provider client
+> (`patch_openai_client`, `patch_anthropic_client`, `patch_genai_client`) on the same code
+> path. A patched call that runs outside an active span emits its own root trace, so every
+> LLM call the framework already traces gets a duplicate trace - and its cost is counted
+> twice.
+
 Two more platforms are covered by **pull importers** rather than in-process hooks, each with its
 own CLI: `agentx-moveworks` (Moveworks Data API sync, no extra needed) and `agentx-databricks`
 (`pip install "agentx-python[databricks]"`, MLflow/Databricks trace sync).

{agentx_python-0.8.22 → agentx_python-0.8.24}/README.md

@@ -190,6 +190,13 @@ extra:
 | LlamaIndex            | `pip install "agentx-python[llamaindex]"`    | `AgentXLlamaIndexHandler` |
 | AutoGen               | `pip install "agentx-python[autogen]"`       | `AgentXAutoGenObserver`   |
 
+> **Warning: pick ONE instrumentation layer per LLM call.** Do not combine
+> `AgentXCallbackHandler` (or any framework integration) with a patched provider client
+> (`patch_openai_client`, `patch_anthropic_client`, `patch_genai_client`) on the same code
+> path. A patched call that runs outside an active span emits its own root trace, so every
+> LLM call the framework already traces gets a duplicate trace - and its cost is counted
+> twice.
+
 Two more platforms are covered by **pull importers** rather than in-process hooks, each with its
 own CLI: `agentx-moveworks` (Moveworks Data API sync, no extra needed) and `agentx-databricks`
 (`pip install "agentx-python[databricks]"`, MLflow/Databricks trace sync).

{agentx_python-0.8.22 → agentx_python-0.8.24}/agentx/agentx.py

@@ -4,6 +4,7 @@ import os
 import logging
 
 from agentx.util import get_headers, api_base, normalize_base
+from agentx.exceptions import AgentXError
 from agentx.resources.agent import Agent
 from agentx.resources.workforce import Workforce
 
@@ -136,6 +137,11 @@ class AgentX:
         return cls(base_url=base_url) if base_url else cls()
 
     def get_agent(self, id: str) -> Agent:
+        """Fetch one hosted-platform agent by id.
+
+        Hosted platform only - the self-host engine does not serve /access/agents;
+        use ``client.monitor.agents.list()`` for self-host agent rows instead.
+        """
         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(self.api_key))
@@ -143,9 +149,17 @@ class AgentX:
         if response.status_code == 200:
             return Agent(**response.json())
         else:
-            raise Exception(f"Failed to retrieve agent: {response.reason}")
+            raise AgentXError(
+                f"Failed to retrieve agent: {response.reason}. This endpoint is "
+                "hosted-platform only - on self-host use client.monitor.agents.list()."
+            )
 
     def list_agents(self) -> List[Agent]:
+        """List the hosted platform's agents.
+
+        Hosted platform only - the self-host engine does not serve /access/agents;
+        use ``client.monitor.agents.list()`` for self-host agent rows instead.
+        """
         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(self.api_key))
@@ -153,7 +167,10 @@ class AgentX:
         if response.status_code == 200:
             return [Agent(**agent) for agent in response.json()]
         else:
-            raise Exception(f"Failed to list agents: {response.reason}")
+            raise AgentXError(
+                f"Failed to list agents: {response.reason}. This endpoint is "
+                "hosted-platform only - on self-host use client.monitor.agents.list()."
+            )
 
     @staticmethod
     def list_workforces() -> List["Workforce"]:
@@ -214,12 +231,18 @@ class AgentX:
         return {"ok": True, "base_url": base}
 
     def get_profile(self):
-        """Get the current user's profile information."""
+        """Get the current user's profile information.
+
+        Hosted platform only - the self-host engine does not serve /access/getProfile;
+        self-host agent/monitoring data lives under ``client.monitor`` (e.g.
+        ``client.monitor.agents.list()``).
+        """
         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:
-            raise Exception(
-                f"Failed to get profile: {response.status_code} - {response.reason}"
+            raise AgentXError(
+                f"Failed to get profile: {response.status_code} - {response.reason}. "
+                "This endpoint is hosted-platform only - on self-host use client.monitor."
             )

{agentx_python-0.8.22 → agentx_python-0.8.24}/agentx/evaluations/client.py

@@ -35,7 +35,6 @@ _DEFAULT_BASE_URL = f"{_UTIL_API_BASE}/custom-agent-evaluations"
 SDK_NAME = "agentx-python"
 
 _RETRYABLE_STATUS = {429, 500, 502, 503, 504}
-_MAX_RETRIES = 3
 _RETRY_BACKOFF = [1.0, 2.0, 4.0]
 
 # The self-host analyze route judges every result before it responds, so the client has to
@@ -182,8 +181,8 @@ class EvaluationsClient:
             if resp.status_code == 422:
                 raise AgentXValidationError(resp.text)
             # 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 entry unreachable for HTTP retries (ingest_client precedent).
+            # schedule connection errors do - an earlier fixed retry-count gate left the
+            # schedule's last entry unreachable for HTTP retries (ingest_client precedent).
             if (
                 resp.status_code in _RETRYABLE_STATUS
                 and retry
@@ -221,7 +220,16 @@ class EvaluationsClient:
         the Sovereignty & Portability Index. Pass ``provider`` (e.g. "Google")
         to filter."""
         params = {"provider": provider} if provider else None
-        data = self._request("GET", "/models", params=params)
+        try:
+            data = self._request("GET", "/models", params=params)
+        except AgentXEvaluationsError as exc:
+            if exc.status_code == 404:
+                raise AgentXEvaluationsError(
+                    "list_models is hosted-only; on self-host pass any model id your judge "
+                    "key can reach, or use client.monitor.* portability models",
+                    status_code=404,
+                ) from exc
+            raise
         items = data if isinstance(data, list) else data.get("models", [])
         return [ModelInfo(**m) for m in items]
 
@@ -239,7 +247,9 @@ class EvaluationsClient:
         """Deletes the dataset, its grading config, and both version histories. Past runs are
         kept (their dataset reference degrades to a bare id). The engine refuses (409) when the
         dataset's config is attached to a live scorer."""
-        self._request("DELETE", f"/datasets/{dataset_id}")
+        # retry=False: a lost response + transport retry would turn a successful
+        # delete into a spurious 404.
+        self._request("DELETE", f"/datasets/{dataset_id}", retry=False)
 
     def list_datasets(self) -> List[Dataset]:
         data = self._request("GET", "/datasets", params=self._workspace_params())
@@ -431,6 +441,12 @@ class EvaluationsClient:
         quality_mode: Optional[str] = None,
         judges: Optional[List[str]] = None,
     ) -> Dict[str, Any]:
+        """Start the qualitative AI-analysis job for a run.
+
+        ``mode`` ("auto"/"sync"/"batch") is hosted-only: self-host engines run the analysis
+        synchronously and ignore it - check the response's mode field for what actually ran
+        (mirrors EvaluationRun.analyze's docstring).
+        """
         # Starts the durable analysis job and returns immediately (e.g. {"jobId": ..., "status":
         # "pending"}); poll get_analysis_status() until it reaches a terminal status, then call
         # get_report(). mode/quality_mode/judges mirror the dashboard's AnalyzeEvaluationRequest.
@@ -497,9 +513,10 @@ class EvaluationsClient:
         return self._report_from_dashboard(run_id)
 
     def get_missing_results(self, run_id: str) -> List[Dict[str, Any]]:
-        """Deprecated: on self-host the route's response body has no top-level list, so this
-        always returns ``[]``. Use :meth:`get_submitted_keys` - the same route's
-        ``submittedKeys`` - to find out what a run still needs."""
+        """Deprecated: on self-host the route returns ``missing: []`` deliberately empty -
+        the engine cannot know the client's case list - so this always returns ``[]``.
+        Use :meth:`get_submitted_keys` - the same route's ``submittedKeys`` - to find out
+        what a run still needs."""
         import warnings
 
         warnings.warn(
@@ -508,8 +525,10 @@ class EvaluationsClient:
             DeprecationWarning,
             stacklevel=2,
         )
-        data = self._request("GET", f"/runs/{run_id}/missing-results")
-        return data if isinstance(data, list) else data.get("missing", [])
+        # No request at all: the route returns `missing: []` deliberately empty (the engine
+        # cannot know the client's case list), so the round-trip only ever bought an empty
+        # result.
+        return []
 
     def get_submitted_keys(self, run_id: str) -> List[str]:
         """Idempotency keys this run has already accepted - what execute() uses to resume a
@@ -546,12 +565,20 @@ class EvaluationsClient:
     ) -> bool:
         """Return True if ``exc`` is the 404 that means "this engine is self-host".
 
-        Only a 404 qualifies. Anything else - auth, validation, a 500, a dead connection -
-        is a real failure on a route that does exist, and must propagate rather than be
-        retried against a different endpoint that would mask it.
+        Only a route-level 404 qualifies. Anything else - auth, validation, a 500, a dead
+        connection - is a real failure on a route that does exist, and must propagate rather
+        than be retried against a different endpoint that would mask it.
+
+        A resource 404 does not qualify either: the engine's SDK router answers these routes
+        with bodies naming the missing resource ("Run not found" / "No analysis found for
+        this run"), so latching on one would permanently reroute every later analysis call
+        to the dashboard router because a caller once passed a wrong run id.
         """
         if exc.status_code != 404:
             return False
+        body = str(exc)
+        if "Run not found" in body or "No analysis found for this run" in body:
+            return False
         if self._analysis_on_dashboard_router is None:
             logger.info(
                 "%s is not served from %s; using the dashboard router at %s "

{agentx_python-0.8.22 → agentx_python-0.8.24}/agentx/evaluations/datasets.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import csv
 import logging
+import warnings
 from pathlib import Path
 from typing import Any, Dict, List, Optional, TYPE_CHECKING, Union
 
@@ -21,7 +22,8 @@ class DatasetBuilder:
     ``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.
+    is dropped by the self-host engine on this route - use
+    ``client.monitor.judge_scorers.builder(sovereignty_models=...)`` which persists it.
     """
 
     def __init__(
@@ -93,8 +95,9 @@ 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). Self-host: accepted on
-        # the wire but not acted on by the engine (see class docstring).
+        # client.evaluations.list_models() to discover valid ids). Self-host: dropped by
+        # the engine on this route - use client.monitor.judge_scorers.builder(
+        # sovereignty_models=...) which persists it (see class docstring).
         if sovereignty_models:
             self._payload["sovereigntyIndex"] = {
                 "enabled": True,
@@ -161,9 +164,11 @@ class DatasetBuilder:
             main["smokeTest"] = {"enabled": True, "count": smoke_test_count}
             if smoke_test_guidance:
                 main["smokeTest"]["guidance"] = smoke_test_guidance
-        if expected_tools:
+        # `is not None`, not truthiness: an explicit empty list is a real assertion (an empty
+        # expectedTrajectory means "this case calls no tools") and must reach the wire.
+        if expected_tools is not None:
             main["expectedTrajectory"] = {"tools": expected_tools, "mode": trajectory_match_mode}
-        if expected_retrieval_context:
+        if expected_retrieval_context is not None:
             main["expectedRetrievalContext"] = expected_retrieval_context
         if splits:
             main["splits"] = splits
@@ -178,6 +183,15 @@ class DatasetBuilder:
     def publish(self) -> Dataset:
         if not self._payload["questions"]:
             raise ValueError("Dataset must have at least one case before publishing")
+        # Warn at publish time, where the request is known: the engine's dataset-create
+        # route drops sovereigntyIndex, so comparison models set here never persist.
+        sov = self._payload.get("sovereigntyIndex")
+        if isinstance(sov, dict) and sov.get("models"):
+            warnings.warn(
+                "Self-host ignores sovereigntyIndex on datasets/grading configs - use "
+                "judge_scorers.builder(sovereignty_models=...) for model comparison runs.",
+                stacklevel=2,
+            )
         logger.info(
             "Publishing dataset '%s' with %d case(s)",
             self._payload["name"],

{agentx_python-0.8.22 → agentx_python-0.8.24}/agentx/evaluations/evaluation_settings.py

@@ -64,8 +64,9 @@ class EvaluationSettingsBuilder:
         if rouge_score:
             self._payload["rougeScore"] = {"enabled": True}
         # Sovereignty & Portability - the models to compare when this config runs
-        # (use client.evaluations.list_models() to discover valid ids). Self-host: accepted
-        # on the wire but not acted on by the engine (same caveat as DatasetBuilder's).
+        # (use client.evaluations.list_models() to discover valid ids). Self-host: dropped
+        # by the engine on this route - use client.monitor.judge_scorers.builder(
+        # sovereignty_models=...) which persists it (same caveat as DatasetBuilder's).
         if sovereignty_models:
             self._payload["sovereigntyIndex"] = {
                 "enabled": True,
@@ -74,10 +75,32 @@ class EvaluationSettingsBuilder:
         # Sandboxed JS scorers run per result alongside the judge - each entry is
         # {"name": ..., "enabled": True, "code": "..."} where the code is a JS function body
         # receiving (input, output, expected, toolCalls) and returning {score, reasoning}.
+        # Normalized the same way DatasetBuilder does: id defaulted, name optional (the
+        # engine defaults it), enabled default True - raw pass-through sent entries the
+        # engine's shape validation rejects.
         if code_scorers:
-            self._payload["codeScorers"] = list(code_scorers)
+            import uuid as _uuid
+
+            self._payload["codeScorers"] = [
+                {
+                    "id": scorer.get("id") or _uuid.uuid4().hex[:12],
+                    "name": scorer.get("name"),
+                    "code": scorer["code"],
+                    "enabled": scorer.get("enabled", True),
+                }
+                for scorer in code_scorers
+            ]
 
     def publish(self) -> EvaluationSettings:
+        # Warn at publish time, where the request is known: the engine's settings-create
+        # route drops sovereigntyIndex, so comparison models set here never persist.
+        sov = self._payload.get("sovereigntyIndex")
+        if isinstance(sov, dict) and sov.get("models"):
+            warnings.warn(
+                "Self-host ignores sovereigntyIndex on datasets/grading configs - use "
+                "judge_scorers.builder(sovereignty_models=...) for model comparison runs.",
+                stacklevel=2,
+            )
         logger.info("Publishing evaluation settings '%s'", self._payload["name"])
         return self._client.create_evaluation_settings(self._payload)
 

{agentx_python-0.8.22 → agentx_python-0.8.24}/agentx/evaluations/models.py

@@ -51,6 +51,10 @@ class TestCase(BaseModel):
     expected_knowledge_base: Optional[List[str]] = Field(default=None, alias="expectedKnowledgeBase")
     expected_delegations: Optional[List[str]] = Field(default=None, alias="expectedDelegations")
     judge_guideline: Optional[str] = Field(default=None, alias="judgeGuideline")
+    # Engine-side trajectory match (e.g. {"tools": ["search"], "mode": "in_order"}) and the
+    # expected retrieval context for RAG grading - carried so import_dataset round-trips them.
+    expected_trajectory: Optional[Dict[str, Any]] = Field(default=None, alias="expectedTrajectory")
+    expected_retrieval_context: Optional[Any] = Field(default=None, alias="expectedRetrievalContext")
     smoke_test: Optional[SmokeTestSettings] = Field(default=None, alias="smokeTest")
     # Named subsets this case belongs to (e.g. ["smoke"], ["full", "regression"]).
     # ``run(dataset_id, split="smoke")`` runs only cases tagged with that split.
@@ -175,27 +179,22 @@ class Prompt(BaseModel):
 # Evaluation subject
 # ---------------------------------------------------------------------------
 
-FrameworkKind = Literal[
-    "raw_python",
-    "openai",
-    "anthropic",
-    "google",
-    "langchain",
-    "llamaindex",
-    "crewai",
-    "autogen",
-    "n8n",
-    "flowise",
-    "other",
-]
-
 RuntimeKind = Literal["local", "ci", "customer_hosted", "low_code"]
 
 
 class EvaluationSubject(BaseModel):
+    """Describes the agent under evaluation.
+
+    ``framework`` is an open string - the engine accepts any label (it also stamps
+    values like ``openai-agents``, ``langgraph``, ``google-genai``, ``litellm`` from
+    the tracing integrations). Common values: ``raw_python``, ``openai``,
+    ``anthropic``, ``google``, ``langchain``, ``llamaindex``, ``crewai``,
+    ``autogen``, ``n8n``, ``flowise``, ``other``.
+    """
+
     kind: Literal["custom_agent", "agentx_agent", "agentx_team"] = "custom_agent"
     display_name: Optional[str] = Field(default=None, alias="displayName")
-    framework: Optional[FrameworkKind] = None
+    framework: Optional[str] = None
     framework_version: Optional[str] = Field(default=None, alias="frameworkVersion")
     runtime: Optional[RuntimeKind] = "local"
     agent_instructions: Optional[str] = Field(default=None, alias="agentInstructions")

{agentx_python-0.8.22 → agentx_python-0.8.24}/agentx/evaluations/reporting.py

@@ -170,9 +170,9 @@ def print_report(report: Report) -> None:
 
     # --- Low-scoring cases ---
     if report.low_scoring_cases:
-        _section("Low-scoring Cases  (rating < 5)")
+        _section("Low-scoring Cases  (rating <= 5)")
         for case in report.low_scoring_cases[:5]:
-            q = (case.get("query") or case.get("questionText", ""))[:80]
+            q = (case.get("query") or case.get("questionText") or "")[:80]
             rating = case.get("rating", "?")
             justification = case.get("justification", "")
             print(f"  {red(f'[{rating}]')} {q}")

{agentx_python-0.8.22 → agentx_python-0.8.24}/agentx/evaluations/results.py

@@ -87,6 +87,16 @@ def normalize_result(
     else:
         output = {"text": str(raw)} if raw is not None else {"text": ""}
 
+    if error is None and (
+        output is None
+        or (set(output) <= {"text"} and not str(output.get("text") or "").strip())
+    ):
+        # An empty output with no error would fail the engine's row validation and silently
+        # vanish from the run - store it as an explicit failed row instead.
+        error = ResultError(type="EmptyOutput", message="Agent returned no output")
+        if output is None:
+            output = {"text": ""}
+
     has_timings = (
         latency_ms is not None or input_tokens is not None or output_tokens is not None
     )

{agentx_python-0.8.22 → agentx_python-0.8.24}/agentx/evaluations/runner.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import logging
 import os
+import sys
 import time
 
 import requests
@@ -228,6 +229,7 @@ class EvaluationRunContext:
                 )
             return normalized(case)
 
+        executor = None
         if concurrency > 1:
             import concurrent.futures
             import contextvars
@@ -307,9 +309,29 @@ class EvaluationRunContext:
             # generator happens to be garbage-collected.
             if results_iter is not None:
                 results_iter.close()
-
-        if batch:
-            self._flush_batch(batch)
+            # And release the pool itself here too: close() on a NEVER-STARTED generator
+            # (e.g. every case was already submitted, so next() was never called) does not
+            # run bounded()'s finally - its executor.shutdown would never fire. shutdown()
+            # is idempotent, so the double call on the normal path is harmless.
+            if executor is not None:
+                executor.shutdown(wait=False, cancel_futures=True)
+            # Flush the trailing partial batch HERE, not after the try: a mid-run exception
+            # (agent crash, Ctrl-C) used to discard up to max_batch - 1 already-paid-for
+            # results still waiting in it.
+            if batch:
+                propagating = sys.exc_info()[1]
+                try:
+                    self._flush_batch(batch)
+                except Exception as flush_exc:
+                    if propagating is None:
+                        raise
+                    # An exception is already propagating out of the loop - a flush failure
+                    # here must not mask it.
+                    logger.error(
+                        "Trailing batch flush failed while handling %r: %s",
+                        propagating,
+                        flush_exc,
+                    )
 
         return self
 
@@ -326,6 +348,15 @@ class EvaluationRunContext:
                     _say(
                         f"  {green('✓')}  Scored {resp.accepted} result{'s' if resp.accepted != 1 else ''}"
                     )
+                    if resp.failed_validation > 0:
+                        # The engine accepts the batch but silently drops rows that fail its
+                        # validation (typically empty output and no error) - say so, or those
+                        # cases just vanish from the report.
+                        _say(
+                            f"  {yellow('!')}  {resp.failed_validation} result"
+                            f"{'s' if resp.failed_validation != 1 else ''} failed validation "
+                            "(empty output and no error) and did not get stored"
+                        )
                     logger.info(
                         "Batch %s: accepted=%d duplicates=%d failed=%d",
                         batch_id[:8],
@@ -415,8 +446,11 @@ class EvaluationRunContext:
         ``no_regression=True`` fails it when the average dropped more than ``tolerance``
         (default 0.5, judge scores are noisy) below the dataset's previous completed run.
         At least one check is required. On a multi-judge run, ``scorer`` (an additional
-        scorer's id or name, e.g. ``scorer="Safety"``) gates that scorer's own average
-        instead of the primary's - "fail if Safety is low even when the average looks fine". Prints a CI-log-friendly verdict and returns a
+        judge scorer's id or name, e.g. ``scorer="Safety"``) gates that scorer's own average
+        instead of the primary's - "fail if Safety is low even when the average looks fine".
+        Only judge scorers resolve here: deterministic scorer-group members (pattern/code
+        kinds) have no per-run judge average, so naming one is rejected by the engine.
+        Prints a CI-log-friendly verdict and returns a
         :class:`GateResult` - the caller decides the exit code::
 
             report = client.evaluations.run(...).execute(my_agent).finalize()
@@ -469,6 +503,16 @@ class EvaluationRunContext:
         """Number of submitted results that have received a rating so far."""
         return self._live_stats.rated_count if self._live_stats else 0
 
+    @property
+    def skipped_count(self) -> int:
+        """Number of submitted results the judge could not score."""
+        return self._live_stats.skipped_count if self._live_stats else 0
+
+    @property
+    def failed_count(self) -> int:
+        """Number of submitted results that carried an error."""
+        return self._live_stats.failed_count if self._live_stats else 0
+
     @property
     def average_rating(self) -> Optional[float]:
         """Live average rating across all results scored so far. Populated as
@@ -509,7 +553,7 @@ class EvaluationRunContext:
                 response's mode field for what actually ran.
             quality_mode: "quality_first" or "balanced" - how many items get a second/third judge.
             judges: 1-3 model ids from ``client.evaluations.list_models()``, e.g.
-                ``["gpt-5.6-luna", "claude-opus-4-8"]``. Omit to let the engine score with its
+                ``["gpt-5.6-luna", "claude-opus-5"]``. Omit to let the engine score with its
                 platform default model (a single judge, rather than the dashboard's 3-judge
                 default - SDK runs are typically lighter-weight, quick-start evaluations).
             poll_interval: seconds between status checks while waiting.
@@ -529,16 +573,27 @@ class EvaluationRunContext:
                     judges=judges,
                 )
                 deadline = time.monotonic() + timeout
-                status = self._client.get_analysis_status(self._run.run_id)
-                while not status.is_terminal and time.monotonic() < deadline:
-                    level = _ANALYSIS_LEVEL_LABELS.get(status.progress.current_level, "")
-                    spinner.update(
-                        f"Analyzing, {level + ' ' if level else ''}{status.progress.overall_percentage}%"
-                    )
+                status = None
+                while True:
+                    try:
+                        status = self._client.get_analysis_status(self._run.run_id)
+                    except Exception as poll_exc:
+                        # One transient status-poll failure (network blip, engine restart)
+                        # must not abort the whole wait - the job keeps running
+                        # server-side, so keep polling until the deadline.
+                        logger.debug("Analysis status poll failed: %s", poll_exc)
+                    if status is not None and status.is_terminal:
+                        break
+                    if time.monotonic() >= deadline:
+                        break
+                    if status is not None:
+                        level = _ANALYSIS_LEVEL_LABELS.get(status.progress.current_level, "")
+                        spinner.update(
+                            f"Analyzing, {level + ' ' if level else ''}{status.progress.overall_percentage}%"
+                        )
                     time.sleep(poll_interval)
-                    status = self._client.get_analysis_status(self._run.run_id)
 
-                if not status.is_terminal:
+                if status is None or not status.is_terminal:
                     _say(f"  {yellow('!')}  Still running after {int(timeout)}s, check the dashboard for status")
                 elif status.status == "failed":
                     reason = status.failure_reason.message if status.failure_reason else "unknown error"
@@ -639,6 +694,36 @@ class EvaluationsRunner:
         script execution)."""
         return self._client.get_analysis_status(run_id)
 
+    # Run-lifecycle calls by id - the standalone forms of what run()/execute()/finalize()/
+    # analyze() drive for you, for scripts operating on a run created elsewhere.
+
+    def init_run(self, dataset_id: str, subject, **kwargs):
+        """Create a run row without executing anything - the standalone form of :meth:`run`.
+        Accepts the same kwargs as ``EvaluationsClient.init_run``."""
+        return self._client.init_run(dataset_id, subject, **kwargs)
+
+    def append_results(self, run_id: str, batch_id: str, results: list):
+        """Submit one batch of results to a run by id (scored synchronously server-side)."""
+        return self._client.append_results(run_id, batch_id, results)
+
+    def finalize_run(self, run_id: str) -> dict:
+        """Mark a run completed by id - the standalone form of
+        ``EvaluationRunContext.finalize()``."""
+        return self._client.finalize_run(run_id)
+
+    def analyze_run(self, run_id: str, **kwargs) -> dict:
+        """Start the LLM analysis of a finalized run by id; poll
+        :meth:`get_analysis_status`, then :meth:`get_report`."""
+        return self._client.analyze_run(run_id, **kwargs)
+
+    def get_report(self, run_id: str):
+        """The analyzed report for a run by id, once analysis has finished."""
+        return self._client.get_report(run_id)
+
+    def get_submitted_keys(self, run_id: str) -> list:
+        """Idempotency keys a run has already accepted - what execute() uses to resume."""
+        return self._client.get_submitted_keys(run_id)
+
     def gate_run(
         self,
         run_id: str,

{agentx_python-0.8.22 → agentx_python-0.8.24}/agentx/integrations/_traced_call.py

@@ -153,7 +153,11 @@ def finish_llm_call(
         )
         return
 
-    span = tracer.trace(name, metadata=metadata, framework=framework, model=model, session_id=session_id)
+    # A patched provider call outside any active span becomes its own root trace - it is a bare
+    # model call, so stamp it "llm" rather than leaving the kind unset.
+    span = tracer.trace(
+        name, metadata=metadata, framework=framework, model=model, session_id=session_id, span_kind="llm"
+    )
     span.__enter__()
     span._start = start_t
     span.input = input_repr

{agentx_python-0.8.22 → agentx_python-0.8.24}/agentx/integrations/autogen.py

@@ -107,7 +107,10 @@ class AgentXAutoGenObserver:
             # explicit return/break/continue there would silently swallow any exception
             # propagating from agent_or_team.run() above (see crewai.py's kickoff() for the same
             # hazard spelled out in full).
-            with self._tracer.trace(self._name, metadata=self._metadata, session_id=self._session_id) as span:
+            # span_kind="agent": the root of a standalone team/agent run is the agent run itself.
+            with self._tracer.trace(
+                self._name, metadata=self._metadata, session_id=self._session_id, span_kind="agent"
+            ) as span:
                 span._start = start_t
                 if error:
                     span.set_error(error)