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

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

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

{agentx_python-0.8.23 → 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.23 → 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
@@ -248,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())
@@ -440,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.
@@ -506,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(
@@ -517,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

{agentx_python-0.8.23 → 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.23 → 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,
@@ -91,6 +92,15 @@ class EvaluationSettingsBuilder:
             ]
 
     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.23 → agentx_python-0.8.24}/agentx/evaluations/models.py

@@ -179,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.23 → agentx_python-0.8.24}/agentx/evaluations/reporting.py

@@ -172,7 +172,7 @@ def print_report(report: Report) -> None:
     if report.low_scoring_cases:
         _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.23 → agentx_python-0.8.24}/agentx/evaluations/runner.py

@@ -229,6 +229,7 @@ class EvaluationRunContext:
                 )
             return normalized(case)
 
+        executor = None
         if concurrency > 1:
             import concurrent.futures
             import contextvars
@@ -308,6 +309,12 @@ class EvaluationRunContext:
             # generator happens to be garbage-collected.
             if results_iter is not None:
                 results_iter.close()
+            # 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.
@@ -546,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.
@@ -566,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"

{agentx_python-0.8.23 → agentx_python-0.8.24}/agentx/integrations/crewai.py

@@ -84,7 +84,7 @@ class AgentXCrewObserver:
             if task_timings:
                 execution_steps, _ = self._build_steps_from_timings(task_timings, task_outputs)
             elif task_outputs:
-                execution_steps, _ = self._build_steps_evenly_divided(task_outputs, latency_ms)
+                execution_steps, _ = self._build_steps_evenly_divided(task_outputs, latency_ms, start)
 
             # Each task becomes its own real child span. tool_calls isn't passed to
             # _merge_child_run here: _build_steps_from_timings/_build_steps_evenly_divided both
@@ -262,25 +262,33 @@ class AgentXCrewObserver:
 
         return execution_steps, tool_calls
 
-    def _build_steps_evenly_divided(self, task_outputs: List[Any], latency_ms: float) -> tuple:
+    def _build_steps_evenly_divided(self, task_outputs: List[Any], latency_ms: float, start: float) -> tuple:
         """
         Fallback for CrewAI versions predating the events module: no
         per-task timing is available, so attribute the total latency evenly
         across tasks so the timeline still sums to the measured wall-clock
-        duration.
+        duration. Each synthesized step also gets a real start_time/end_time
+        (consecutive per_step_s slices from the kickoff's start) so the
+        dashboard timeline can position it, not just size it.
         """
         tool_calls: List[Dict[str, Any]] = []
         execution_steps: List[Dict[str, Any]] = []
-        for task_out in task_outputs:
+        per_step_ms = latency_ms / len(task_outputs)
+        per_step_s = per_step_ms / 1000.0
+        for i, task_out in enumerate(task_outputs):
             description = getattr(task_out, "description", "task")
             name = description[:100]
             task_output = str(getattr(task_out, "raw", ""))
             tool_calls.append({"name": name, "input": description, "output": task_output})
-            execution_steps.append({"name": name, "duration_ms": 0, "input": description, "output": task_output})
-
-        per_step_ms = latency_ms / len(execution_steps)
-        for step in execution_steps:
-            step["duration_ms"] = per_step_ms
+            step_start = start + i * per_step_s
+            execution_steps.append({
+                "name": name,
+                "duration_ms": per_step_ms,
+                "start_time": step_start,
+                "end_time": step_start + per_step_s,
+                "input": description,
+                "output": task_output,
+            })
 
         return execution_steps, tool_calls
 
@@ -307,4 +315,6 @@ class AgentXCrewObserver:
             framework="crewai",
             session_id=session_id or self._session_id,
             sync=sync,
+            # Same statement kickoff() makes: the root of a crew run is the agent run itself.
+            span_kind="agent",
         )

{agentx_python-0.8.23 → agentx_python-0.8.24}/agentx/integrations/google_adk.py

@@ -20,12 +20,15 @@ Requires: ``pip install "agentx-python[google-adk]"``
 """
 from __future__ import annotations
 
+import logging
 import time
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Tuple
 from uuid import uuid4
 
 from agentx.tracing.tracer import Tracer, _safe_serialize
 
+logger = logging.getLogger(__name__)
+
 try:
     from google.adk.plugins.base_plugin import BasePlugin
 except ImportError as exc:  # pragma: no cover
@@ -94,23 +97,34 @@ class AgentXADKPlugin(BasePlugin):
         name: str = "google-adk-agent",
         metadata: Optional[Dict[str, Any]] = None,
         session_id: Optional[str] = None,
+        max_run_age_seconds: float = 3600.0,
     ) -> None:
         super().__init__(name="agentx")
         self._tracer = tracer
         self._agent_name = name
         self._metadata = metadata
         self._session_id = session_id
+        # Safety net mirroring langchain.py's _prune_stale_entries: state is normally popped
+        # in after_run_callback, but an invocation whose end callback never fires (hard
+        # crash, ADK bug) would leak forever in this long-lived plugin. Entries older than
+        # this are swept out at the top of before_run_callback.
+        self._max_run_age_seconds = max_run_age_seconds
         # invocation_id → accumulated run state
         self._runs: Dict[str, Dict[str, Any]] = {}
-        # invocation_id → pre-buffered user input text
+        # invocation_id → (pre-buffered user input text, buffered-at time)
         # (on_user_message_callback fires *before* before_run_callback)
-        self._pending_inputs: Dict[str, str] = {}
-        # id(tool_context) → start time float
-        self._tool_starts: Dict[int, float] = {}
-        # invocation_id → stack of model call start times (FIFO)
+        self._pending_inputs: Dict[str, Tuple[str, float]] = {}
+        # (invocation_id, tool name) → FIFO list of start times, mirroring _model_starts:
+        # parallel same-name tool calls each push their own start, so a second start no
+        # longer overwrites the first (a scalar here lost the first call's timing). Keyed
+        # by invocation_id, not id(tool_context): ADK creates fresh context objects per
+        # callback (see _model_starts' comment), and a freed context's id() can be
+        # recycled by an unrelated object, pairing a start with the wrong end.
+        self._tool_starts: Dict[Tuple[str, str], List[float]] = {}
+        # invocation_id → FIFO list of per-call dicts ({"start", "model", "input"})
         # ADK creates new CallbackContext objects for before/after model callbacks,
         # so we cannot use id(callback_context) as a key - use invocation_id instead.
-        self._model_starts: Dict[str, List[float]] = {}
+        self._model_starts: Dict[str, List[Dict[str, Any]]] = {}
 
     # ------------------------------------------------------------------
     # Run lifecycle
@@ -124,9 +138,64 @@ class AgentXADKPlugin(BasePlugin):
         inv_id = invocation_context.invocation_id
         text = _content_to_text(user_message)
         if text:
-            self._pending_inputs[inv_id] = text
+            self._pending_inputs[inv_id] = (text, time.time())
+
+    def _prune_stale_entries(self) -> None:
+        """Sweep out invocation entries older than max_run_age_seconds - see __init__'s comment."""
+        cutoff = time.time() - self._max_run_age_seconds
+        swept = 0
+
+        stale_inv_ids = [
+            inv_id
+            for inv_id, state in list(self._runs.items())
+            if (getattr(state.get("root_span"), "_start", None) or 0) < cutoff
+        ]
+        for inv_id in stale_inv_ids:
+            self._runs.pop(inv_id, None)
+            self._model_starts.pop(inv_id, None)
+            self._pending_inputs.pop(inv_id, None)
+            for key in [k for k in self._tool_starts if k[0] == inv_id]:
+                self._tool_starts.pop(key, None)
+        swept += len(stale_inv_ids)
+
+        # Orphaned per-call state whose invocation state is already gone (or never existed) -
+        # each entry carries its own timestamp.
+        stale_model_ids = [
+            inv_id
+            for inv_id, starts in list(self._model_starts.items())
+            if inv_id not in self._runs
+            and (not starts or max(call.get("start", 0) for call in starts) < cutoff)
+        ]
+        for inv_id in stale_model_ids:
+            self._model_starts.pop(inv_id, None)
+        swept += len(stale_model_ids)
+
+        stale_tool_keys = [
+            key
+            for key, starts in list(self._tool_starts.items())
+            if not starts or max(starts) < cutoff
+        ]
+        for key in stale_tool_keys:
+            self._tool_starts.pop(key, None)
+        swept += len(stale_tool_keys)
+
+        stale_input_ids = [
+            inv_id for inv_id, pending in list(self._pending_inputs.items()) if pending[1] < cutoff
+        ]
+        for inv_id in stale_input_ids:
+            self._pending_inputs.pop(inv_id, None)
+        swept += len(stale_input_ids)
+
+        if swept:
+            logger.warning(
+                "AgentXADKPlugin swept %d in-flight invocation record(s) older than %.0fs - "
+                "their end callbacks never fired, so their traces were never sent",
+                swept,
+                self._max_run_age_seconds,
+            )
 
     async def before_run_callback(self, *, invocation_context: Any) -> None:
+        self._prune_stale_entries()
         inv_id = invocation_context.invocation_id
         agent_name = getattr(invocation_context.agent, "name", None) or self._agent_name
         # Held directly (not relied on via tracer.current_span) - ADK callbacks for one
@@ -134,7 +203,13 @@ class AgentXADKPlugin(BasePlugin):
         # same thread/task, so state["root_span"] (keyed by invocation_id, same as everything
         # else here) is the reliable way to address the right parent.
         root_span = self._tracer.trace(
-            agent_name, framework="google-adk", metadata=self._metadata, session_id=self._session_id
+            agent_name,
+            framework="google-adk",
+            metadata=self._metadata,
+            session_id=self._session_id,
+            # The root of a standalone runner invocation is the agent run itself
+            # (langchain/llamaindex/crewai/autogen parity).
+            span_kind="agent",
         )
         # Deliberately NOT root_span.__enter__() - the same reasoning as openai_agents'
         # on_trace_start: enter pushes onto the CALLING context's active-span stack, but ADK
@@ -146,10 +221,11 @@ class AgentXADKPlugin(BasePlugin):
         root_span._start = time.time()
         if root_span._session_id is None:
             root_span._session_id = f"sdk_{uuid4().hex}"
+        pending_input = self._pending_inputs.pop(inv_id, None)
         self._runs[inv_id] = {
             "root_span": root_span,
             "llm_call_count": 0,
-            "input": self._pending_inputs.pop(inv_id, None),
+            "input": pending_input[0] if pending_input else None,
             "output": None,
             "model": None,
             "error": None,
@@ -160,6 +236,10 @@ class AgentXADKPlugin(BasePlugin):
     async def after_run_callback(self, *, invocation_context: Any) -> None:
         inv_id = invocation_context.invocation_id
         state = self._runs.pop(inv_id, None)
+        # Drop this invocation's per-call leftovers too - an unpaired before_model_callback
+        # (or an input buffered after the run started) would otherwise leak here forever.
+        self._model_starts.pop(inv_id, None)
+        self._pending_inputs.pop(inv_id, None)
         if state is None:
             return
         # This invocation's own detail already went out as child-span rows via child_span() in
@@ -285,7 +365,10 @@ class AgentXADKPlugin(BasePlugin):
     async def before_tool_callback(
         self, *, tool: Any, tool_args: Dict[str, Any], tool_context: Any
     ) -> None:
-        self._tool_starts[id(tool_context)] = time.time()
+        inv_id = tool_context.get_invocation_context().invocation_id
+        # FIFO list per (invocation, tool name) - parallel same-name calls each queue
+        # their own start (see __init__'s comment).
+        self._tool_starts.setdefault((inv_id, getattr(tool, "name", "unknown")), []).append(time.time())
 
     async def after_tool_callback(
         self,
@@ -299,9 +382,15 @@ class AgentXADKPlugin(BasePlugin):
         state = self._runs.get(inv_id)
         if state is None:
             return
-        start_t = self._tool_starts.pop(id(tool_context), None)
-        end_t = time.time()
         tool_name = getattr(tool, "name", "unknown")
+        # Pop the earliest queued start (FIFO, _model_starts' pairing), dropping the
+        # key once its list drains so entries don't accumulate.
+        key = (inv_id, tool_name)
+        starts = self._tool_starts.get(key, [])
+        start_t = starts.pop(0) if starts else None
+        if not starts:
+            self._tool_starts.pop(key, None)
+        end_t = time.time()
         tool_input = _safe_serialize(tool_args)
         tool_output = str(result) if result is not None else None
         state["root_span"].child_span(
@@ -331,9 +420,15 @@ class AgentXADKPlugin(BasePlugin):
         state = self._runs.get(inv_id)
         if state is None:
             return
-        start_t = self._tool_starts.pop(id(tool_context), None)
-        end_t = time.time()
         tool_name = getattr(tool, "name", "unknown")
+        # Pop the earliest queued start (FIFO, _model_starts' pairing), dropping the
+        # key once its list drains so entries don't accumulate.
+        key = (inv_id, tool_name)
+        starts = self._tool_starts.get(key, [])
+        start_t = starts.pop(0) if starts else None
+        if not starts:
+            self._tool_starts.pop(key, None)
+        end_t = time.time()
         tool_input = _safe_serialize(tool_args)
         tool_output = f"ERROR: {error}"
         state["root_span"].child_span(