agentx-python 0.6.11__tar.gz → 0.6.13__tar.gz

{agentx_python-0.6.11/agentx_python.egg-info → agentx_python-0.6.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentx-python
-Version: 0.6.11
+Version: 0.6.13
 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
@@ -298,6 +298,19 @@ Per-agent coverage/threshold settings (sample rate, retention, and threshold ove
 client.monitor.profile.update("agent_123", threshold_overrides={"latencyMs": 15000})
 ```
 
+Self-host also has **online evaluators**: a real LLM judge scoring a sample of live traffic continuously, distinct from a pattern's rule-matching. A score below `alert_threshold` raises a signal the same way a failing pattern does, deduped and triage-ready in `client.monitor.signals`.
+
+```python
+evaluator = client.monitor.online_evaluators.builder(
+    name="Helpfulness",
+    evaluation_settings_id=settings.id,
+    sample_rate=0.1,
+    alert_threshold=5,
+).publish()
+
+client.monitor.online_evaluators.ratings(evaluator.id, window="7d")
+```
+
 See **[TRACING.md](TRACING.md)** for the complete Monitor guide.
 
 ---
@@ -330,7 +343,7 @@ Ask a case's question several extra ways each run, LLM-paraphrased server-side,
 Since AgentX doesn't own your agent's code, `client.evaluations.prompts` lets AgentX become your prompt's *source of truth* instead — the same problem LangSmith's Prompt Hub and Langfuse's Prompt Management solve. Pull a version at runtime, tag your eval runs (or live traces) with it, and let a judge propose a rewrite from your real worst-rated results — a human always has to approve before it publishes:
 
 ```python
-prompt = client.evaluations.prompts.get("support-agent-system-prompt")
+prompt = client.evaluations.prompts.get("support-agent-system-prompt")  # or prompt.id
 # use prompt.text as your own agent's system prompt
 
 client.evaluations.run(

{agentx_python-0.6.11 → agentx_python-0.6.13}/README.md

@@ -236,6 +236,19 @@ Per-agent coverage/threshold settings (sample rate, retention, and threshold ove
 client.monitor.profile.update("agent_123", threshold_overrides={"latencyMs": 15000})
 ```
 
+Self-host also has **online evaluators**: a real LLM judge scoring a sample of live traffic continuously, distinct from a pattern's rule-matching. A score below `alert_threshold` raises a signal the same way a failing pattern does, deduped and triage-ready in `client.monitor.signals`.
+
+```python
+evaluator = client.monitor.online_evaluators.builder(
+    name="Helpfulness",
+    evaluation_settings_id=settings.id,
+    sample_rate=0.1,
+    alert_threshold=5,
+).publish()
+
+client.monitor.online_evaluators.ratings(evaluator.id, window="7d")
+```
+
 See **[TRACING.md](TRACING.md)** for the complete Monitor guide.
 
 ---
@@ -268,7 +281,7 @@ Ask a case's question several extra ways each run, LLM-paraphrased server-side,
 Since AgentX doesn't own your agent's code, `client.evaluations.prompts` lets AgentX become your prompt's *source of truth* instead — the same problem LangSmith's Prompt Hub and Langfuse's Prompt Management solve. Pull a version at runtime, tag your eval runs (or live traces) with it, and let a judge propose a rewrite from your real worst-rated results — a human always has to approve before it publishes:
 
 ```python
-prompt = client.evaluations.prompts.get("support-agent-system-prompt")
+prompt = client.evaluations.prompts.get("support-agent-system-prompt")  # or prompt.id
 # use prompt.text as your own agent's system prompt
 
 client.evaluations.run(

{agentx_python-0.6.11 → agentx_python-0.6.13}/agentx/evaluations/client.py

@@ -213,6 +213,8 @@ class EvaluationsClient:
         return [Prompt(**p) for p in (data if isinstance(data, list) else data.get("prompts", []))]
 
     def get_prompt(self, name: str, version: Optional[int] = None) -> Prompt:
+        # `name` doubles as an id: the backend route tries a name match first, then falls back to
+        # an id match (see engine's getPromptRowByNameOrId), so callers can pass either.
         params = self._workspace_params() or {}
         if version is not None:
             params = {**params, "version": version}

{agentx_python-0.6.11 → agentx_python-0.6.13}/agentx/evaluations/models.py

@@ -132,7 +132,7 @@ class EvaluationSettings(BaseModel):
 # Prompt registry — the external-agent analog to AgentX's native autotune. AgentX doesn't own
 # your agent's code, so instead of branching/applying a config it becomes the prompt's source of
 # truth (same shape as LangSmith's Prompt Hub / Langfuse's Prompt Management): pull a version at
-# runtime with ``client.evaluations.prompts.get(name)``, use ``prompt.text`` as your agent's
+# runtime with ``client.evaluations.prompts.get(name_or_id)``, use ``prompt.text`` as your agent's
 # system prompt, and tag your eval runs so the existing version-comparison view can tell you
 # which published version scored higher — see ``client.evaluations.prompts`` docs.
 # ---------------------------------------------------------------------------

{agentx_python-0.6.11 → agentx_python-0.6.13}/agentx/evaluations/prompts.py

@@ -34,6 +34,9 @@ class PromptClient:
                 }
             ),
         )
+
+    ``get()`` also accepts a prompt's ``id`` in place of its name, e.g.
+    ``client.evaluations.prompts.get(prompt.id)``.
     """
 
     def __init__(self, client: "EvaluationsClient"):
@@ -43,6 +46,9 @@ class PromptClient:
         return self._client.create_prompt({"name": name, "text": text, "description": description})
 
     def get(self, name: str, version: Optional[int] = None) -> Prompt:
+        """Accepts either the prompt's name or its ``id`` (e.g. ``prompt.id`` from an earlier
+        ``get``/``create`` call), useful for round-tripping an id you already have without a
+        second lookup method."""
         return self._client.get_prompt(name, version=version)
 
     def list(self) -> List[Prompt]:

{agentx_python-0.6.11 → agentx_python-0.6.13}/agentx/integrations/_traced_call.py

@@ -16,7 +16,6 @@ import inspect
 from typing import Any, Callable, Dict, Optional
 
 from agentx.tracing.tracer import Tracer
-from agentx.integrations._perf import build_performance_summary
 
 
 def call_and_trace(
@@ -82,15 +81,16 @@ def finish_llm_call(
     """
     Close out one raw-client LLM call — shared by the ``on_finish``/exit
     callbacks of every integration that patches a raw provider client
-    (``anthropic.py``, ``google_genai.py``, ``openai.py``) rather than a
+    (``anthropic.py``, ``google_genai.py``, ``openai.py``, ``litellm.py``) rather than a
     framework-level callback/plugin system.
 
-    If the call happened inside a ``with tracer.trace(...)`` block, attach it
-    as one LLM-call step on that span instead of sending an independent
-    trace — the same "part of a multi-call agentic loop" behavior
-    ``anthropic.py`` already had; folded in here so every raw-client
-    integration gets it instead of each having to remember to check
-    ``tracer.current_span`` itself.
+    If the call happened inside a ``with tracer.trace(...)`` block, it becomes that span's own
+    real child span (via _record_llm_call) instead of an independent trace — the same "part of a
+    multi-call agentic loop" behavior ``anthropic.py`` already had; folded in here so every
+    raw-client integration gets it instead of each having to remember to check
+    ``tracer.current_span`` itself. Otherwise it becomes its own real root span, opened/closed
+    directly here (not via ``tracer._send()``) so it still gets a real span_id/session_id and the
+    call's exact timing rather than wall-clock "now".
     """
     latency_ms = int((end_t - start_t) * 1000)
 
@@ -110,32 +110,15 @@ def finish_llm_call(
         )
         return
 
-    perf = build_performance_summary(
-        total_duration_ms=latency_ms,
-        execution_steps=[{
-            "name": "LLM Call 1",
-            "duration_ms": latency_ms,
-            "start_time": start_t,
-            "end_time": end_t,
-            "model": model,
-            "input": input_repr,
-            "output": output,
-            "inputTokenSize": input_tokens,
-            "outputTokenSize": output_tokens,
-        }],
-        has_errors=error is not None,
-    )
-    tracer._send(
-        name=name,
-        input=input_repr,
-        output=output,
-        latency_ms=latency_ms,
-        error=error,
-        framework=framework,
-        model=model,
-        metadata=metadata,
-        session_id=session_id,
-        performance_summary=perf,
-        input_tokens=input_tokens,
-        output_tokens=output_tokens,
-    )
+    span = tracer.trace(name, metadata=metadata, framework=framework, model=model, session_id=session_id)
+    span.__enter__()
+    span._start = start_t
+    span.input = input_repr
+    span.output = output
+    if error:
+        span.set_error(error)
+    if input_tokens:
+        span._input_tokens = input_tokens
+    if output_tokens:
+        span._output_tokens = output_tokens
+    span.__exit__(None, None, None)

{agentx_python-0.6.11 → agentx_python-0.6.13}/agentx/integrations/autogen.py

@@ -23,7 +23,6 @@ import time
 from typing import Any, Dict, List, Optional
 
 from agentx.tracing.tracer import Tracer, _safe_serialize
-from agentx.integrations._perf import build_performance_summary
 
 
 def _message_text(message: Any) -> Optional[str]:
@@ -93,8 +92,6 @@ class AgentXAutoGenObserver:
             error = str(exc)
             raise
         finally:
-            end_t = time.time()
-            latency_ms = int((end_t - start_t) * 1000)
             messages = getattr(result, "messages", None) or []
             execution_steps, tool_call_steps, output_text, input_tokens, output_tokens = self._summarize_messages(
                 messages, start_t
@@ -106,24 +103,23 @@ class AgentXAutoGenObserver:
             # normalized .content, regardless of which form was passed in.
             input_text = _message_text(messages[0]) if messages else (task if isinstance(task, str) else None)
 
-            self._tracer._send(
-                name=self._name,
-                input=input_text,
-                output=output_text,
-                latency_ms=latency_ms,
-                error=error,
-                framework="autogen",
-                metadata=self._metadata,
-                session_id=self._session_id,
-                performance_summary=build_performance_summary(
-                    total_duration_ms=latency_ms,
+            # No `return` here — this whole block runs inside the try's `finally`, and an
+            # 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._start = start_t
+                if error:
+                    span.set_error(error)
+                span._merge_child_run(
                     execution_steps=execution_steps,
-                    tool_call_steps=tool_call_steps,
-                    has_errors=error is not None,
-                ),
-                input_tokens=input_tokens or None,
-                output_tokens=output_tokens or None,
-            )
+                    tool_calls=tool_call_steps,
+                    input=input_text,
+                    output=output_text,
+                    framework="autogen",
+                    input_tokens=input_tokens or None,
+                    output_tokens=output_tokens or None,
+                )
 
     def _summarize_messages(self, messages: List[Any], run_start: float) -> tuple:
         execution_steps: List[Dict[str, Any]] = []

{agentx_python-0.6.11 → agentx_python-0.6.13}/agentx/integrations/crewai.py

@@ -22,7 +22,6 @@ import time
 from typing import Any, Dict, List, Optional
 
 from agentx.tracing.tracer import Tracer, _safe_serialize
-from agentx.integrations._perf import build_performance_summary
 
 
 class AgentXCrewObserver:
@@ -73,35 +72,30 @@ class AgentXCrewObserver:
                 output = getattr(result, "raw", None) or _safe_serialize(result)
 
             task_outputs = list(getattr(result, "tasks_output", []) or []) if result is not None else []
-            tool_calls: List[Dict[str, Any]] = []
             execution_steps: List[Dict[str, Any]] = []
 
             if task_timings:
-                execution_steps, tool_calls = self._build_steps_from_timings(task_timings, task_outputs)
+                execution_steps, _ = self._build_steps_from_timings(task_timings, task_outputs)
             elif task_outputs:
-                execution_steps, tool_calls = self._build_steps_evenly_divided(task_outputs, latency_ms)
-
-            if not execution_steps:
-                # No per-task breakdown available — record the whole kickoff
-                # as a single step so the trace still gets timing detail.
-                execution_steps.append({"name": self._name, "duration_ms": latency_ms})
-
-            self._tracer._send(
-                name=self._name,
-                input=_safe_serialize(inputs) if inputs else None,
-                output=output,
-                latency_ms=latency_ms,
-                error=error,
-                framework="crewai",
-                tool_calls=tool_calls or None,
-                metadata=self._metadata,
-                session_id=self._session_id,
-                performance_summary=build_performance_summary(
-                    total_duration_ms=latency_ms,
+                execution_steps, _ = self._build_steps_evenly_divided(task_outputs, latency_ms)
+
+            # 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
+            # build it from the exact same per-task loop as execution_steps (no separate timing of
+            # its own), so passing both would double-emit each task as two child spans. No
+            # `return` here (this whole method body runs inside the try's `finally`) — an
+            # explicit return/break/continue in a finally block silently swallows any exception
+            # propagating from crew.kickoff() above.
+            with self._tracer.trace(self._name, metadata=self._metadata, session_id=self._session_id) as span:
+                span._start = start
+                if error:
+                    span.set_error(error)
+                span._merge_child_run(
                     execution_steps=execution_steps,
-                    has_errors=error is not None,
-                ),
-            )
+                    input=_safe_serialize(inputs) if inputs else None,
+                    output=output,
+                    framework="crewai",
+                )
 
     def _start_task_timing_capture(self):
         """

{agentx_python-0.6.11 → agentx_python-0.6.13}/agentx/integrations/google_adk.py

@@ -24,7 +24,6 @@ import time
 from typing import Any, Dict, List, Optional
 
 from agentx.tracing.tracer import Tracer, _safe_serialize
-from agentx.integrations._perf import build_performance_summary
 
 try:
     from google.adk.plugins.base_plugin import BasePlugin
@@ -82,7 +81,8 @@ class AgentXADKPlugin(BasePlugin):
     Google ADK plugin that sends one AgentX trace per runner invocation.
 
     Captures input (user message), output (final model reply), model name,
-    tool calls, latency, and a performance_summary via the ADK plugin callbacks.
+    tool calls, and latency, each model/tool call as its own real child span of the
+    invocation's root, via the ADK plugin callbacks.
 
     Register via the ``plugins`` list when constructing the ADK ``Runner``.
     """
@@ -128,16 +128,21 @@ class AgentXADKPlugin(BasePlugin):
     async def before_run_callback(self, *, invocation_context: Any) -> None:
         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
+        # invocation can interleave with callbacks for a different concurrent invocation on the
+        # 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
+        )
+        root_span.__enter__()
         self._runs[inv_id] = {
-            "start": time.time(),
-            "name": agent_name,
+            "root_span": root_span,
+            "llm_call_count": 0,
             "input": self._pending_inputs.pop(inv_id, None),
             "output": None,
             "model": None,
-            "tool_calls": [],
             "error": None,
-            "execution_steps": [],
-            "perf_tool_calls": [],
             "input_tokens": 0,
             "output_tokens": 0,
         }
@@ -147,27 +152,18 @@ class AgentXADKPlugin(BasePlugin):
         state = self._runs.pop(inv_id, None)
         if state is None:
             return
-        latency_ms = int((time.time() - state["start"]) * 1000)
-        perf = build_performance_summary(
-            total_duration_ms=latency_ms,
-            execution_steps=state["execution_steps"],
-            tool_call_steps=state["perf_tool_calls"],
-        )
-        self._tracer._send(
-            name=state["name"],
-            input=state["input"],
-            output=state["output"],
-            latency_ms=latency_ms,
-            error=state["error"],
-            framework="google-adk",
-            model=state["model"],
-            tool_calls=state["tool_calls"] or None,
-            metadata=self._metadata,
-            session_id=self._session_id,
-            performance_summary=perf,
-            input_tokens=state["input_tokens"] or None,
-            output_tokens=state["output_tokens"] or None,
-        )
+        # This invocation's own detail already went out as child-span rows via child_span() in
+        # the model/tool callbacks below — this just closes the root with a summary
+        # input/output/model/error/tokens.
+        root_span = state["root_span"]
+        root_span.input = state["input"]
+        root_span.output = state["output"]
+        root_span._captured_model = state["model"]
+        root_span._input_tokens = state["input_tokens"]
+        root_span._output_tokens = state["output_tokens"]
+        if state["error"]:
+            root_span.set_error(state["error"])
+        root_span.__exit__(None, None, None)
 
     # ------------------------------------------------------------------
     # Model callbacks — capture model name, output, and LLM step timing
@@ -223,20 +219,19 @@ class AgentXADKPlugin(BasePlugin):
         if call_output_tokens is not None:
             state["output_tokens"] += int(call_output_tokens)
 
-        # Execution step
+        # Execution step — a real child span of this invocation's root.
         if start_t is not None:
-            steps = state["execution_steps"]
-            steps.append({
-                "name": f"LLM Call {len(steps) + 1}",
-                "duration_ms": (end_t - start_t) * 1000,
-                "start_time": start_t,
-                "end_time": end_t,
-                "model": call_start.get("model") if call_start else None,
-                "input": call_start.get("input") if call_start else None,
-                "output": text,
-                "inputTokenSize": call_input_tokens,
-                "outputTokenSize": call_output_tokens,
-            })
+            state["llm_call_count"] += 1
+            state["root_span"].child_span(
+                f"LLM Call {state['llm_call_count']}",
+                start_time=start_t,
+                end_time=end_t,
+                input=call_start.get("input") if call_start else None,
+                output=text,
+                model=call_start.get("model") if call_start else None,
+                input_tokens=call_input_tokens,
+                output_tokens=call_output_tokens,
+            )
 
     async def on_model_error_callback(
         self, *, callback_context: Any, llm_request: Any, error: Exception
@@ -257,16 +252,16 @@ class AgentXADKPlugin(BasePlugin):
         state["error"] = str(error)
 
         if start_t is not None:
-            steps = state["execution_steps"]
-            steps.append({
-                "name": f"LLM Call {len(steps) + 1}",
-                "duration_ms": (end_t - start_t) * 1000,
-                "start_time": start_t,
-                "end_time": end_t,
-                "model": call_start.get("model") if call_start else None,
-                "input": call_start.get("input") if call_start else None,
-                "output": f"ERROR: {error}",
-            })
+            state["llm_call_count"] += 1
+            state["root_span"].child_span(
+                f"LLM Call {state['llm_call_count']}",
+                start_time=start_t,
+                end_time=end_t,
+                input=call_start.get("input") if call_start else None,
+                output=f"ERROR: {error}",
+                model=call_start.get("model") if call_start else None,
+                error=str(error),
+            )
 
     # ------------------------------------------------------------------
     # Tool callbacks
@@ -294,23 +289,9 @@ class AgentXADKPlugin(BasePlugin):
         tool_name = getattr(tool, "name", "unknown")
         tool_input = _safe_serialize(tool_args)
         tool_output = str(result) if result is not None else None
-        tool_call: Dict[str, Any] = {
-            "name": tool_name,
-            "input": tool_input,
-            "output": tool_output,
-        }
-        if start_t is not None:
-            tool_call["latency_ms"] = max(0, int((end_t - start_t) * 1000))
-        state["tool_calls"].append(tool_call)
-        if start_t is not None:
-            state["perf_tool_calls"].append({
-                "name": tool_name,
-                "duration_ms": (end_t - start_t) * 1000,
-                "start_time": start_t,
-                "end_time": end_t,
-                "input": tool_input,
-                "output": tool_output,
-            })
+        state["root_span"].child_span(
+            tool_name, start_time=start_t, end_time=end_t, input=tool_input, output=tool_output
+        )
 
     async def on_tool_error_callback(
         self,
@@ -329,20 +310,6 @@ class AgentXADKPlugin(BasePlugin):
         tool_name = getattr(tool, "name", "unknown")
         tool_input = _safe_serialize(tool_args)
         tool_output = f"ERROR: {error}"
-        tool_call: Dict[str, Any] = {
-            "name": tool_name,
-            "input": tool_input,
-            "output": tool_output,
-        }
-        if start_t is not None:
-            tool_call["latency_ms"] = max(0, int((end_t - start_t) * 1000))
-        state["tool_calls"].append(tool_call)
-        if start_t is not None:
-            state["perf_tool_calls"].append({
-                "name": tool_name,
-                "duration_ms": (end_t - start_t) * 1000,
-                "start_time": start_t,
-                "end_time": end_t,
-                "input": tool_input,
-                "output": tool_output,
-            })
+        state["root_span"].child_span(
+            tool_name, start_time=start_t, end_time=end_t, input=tool_input, output=tool_output, error=str(error)
+        )

{agentx_python-0.6.11 → agentx_python-0.6.13}/agentx/integrations/langchain.py

@@ -26,7 +26,6 @@ from typing import Any, Dict, List, Optional, Union
 from uuid import UUID
 
 from agentx.tracing.tracer import Tracer, _safe_serialize
-from agentx.integrations._perf import build_performance_summary
 
 try:
     from langchain_core.callbacks.base import BaseCallbackHandler
@@ -329,7 +328,6 @@ class AgentXCallbackHandler(BaseCallbackHandler):
                 "tool_calls": [],
                 "model": None,
                 "execution_steps": [],
-                "perf_tool_calls": [],
                 "retrieval_steps": pending,
                 "input_tokens": 0,
                 "output_tokens": 0,
@@ -355,7 +353,6 @@ class AgentXCallbackHandler(BaseCallbackHandler):
         state = self._runs.pop(run_id, None)
         if state is None:
             return
-        latency_ms = int((time.time() - state["start"]) * 1000)
         output = _extract_output(outputs)
         # Each tool_call dict already carries its own start_time/end_time (set in
         # on_tool_end/on_tool_error), so no re-pairing against perf_tool_calls by
@@ -383,26 +380,24 @@ class AgentXCallbackHandler(BaseCallbackHandler):
                 output_tokens=state["output_tokens"] or None,
             )
         else:
-            perf = build_performance_summary(
-                total_duration_ms=latency_ms,
-                execution_steps=state["execution_steps"],
-                tool_call_steps=state["perf_tool_calls"],
-                retrieval_steps=state["retrieval_steps"],
-            )
-            self._tracer._send(
-                name=self._name,
-                input=state["input"],
-                output=output,
-                latency_ms=latency_ms,
-                framework="langchain",
-                model=state.get("model"),
-                tool_calls=tool_calls or None,
-                metadata=self._metadata,
-                session_id=self._session_id,
-                performance_summary=perf,
-                input_tokens=state["input_tokens"] or None,
-                output_tokens=state["output_tokens"] or None,
-            )
+            # Standalone usage (no enclosing `with tracer.trace()`): open a real root span for
+            # this chain invocation and let _merge_child_run explode its accumulated
+            # execution_steps/tool_calls/retrieval_steps into real child-span rows.
+            with self._tracer.trace(self._name, metadata=self._metadata, session_id=self._session_id) as span:
+                # __enter__ just set _start to "now" — overridden to the chain's real start time,
+                # see llamaindex.py's _send_trace for the identical fix and full rationale.
+                span._start = state["start"]
+                span._merge_child_run(
+                    execution_steps=state["execution_steps"],
+                    tool_calls=tool_calls,
+                    retrieval_steps=state["retrieval_steps"],
+                    input=state["input"],
+                    output=output,
+                    model=state.get("model"),
+                    framework="langchain",
+                    input_tokens=state["input_tokens"] or None,
+                    output_tokens=state["output_tokens"] or None,
+                )
 
     def on_chain_error(
         self,
@@ -420,7 +415,6 @@ class AgentXCallbackHandler(BaseCallbackHandler):
         state = self._runs.pop(run_id, None)
         if state is None:
             return
-        latency_ms = int((time.time() - state["start"]) * 1000)
 
         active_span = self._tracer.current_span
         if active_span is not None:
@@ -436,27 +430,20 @@ class AgentXCallbackHandler(BaseCallbackHandler):
                 output_tokens=state["output_tokens"] or None,
             )
         else:
-            perf = build_performance_summary(
-                total_duration_ms=latency_ms,
-                execution_steps=state["execution_steps"],
-                tool_call_steps=state["perf_tool_calls"],
-                retrieval_steps=state["retrieval_steps"],
-                has_errors=True,
-            )
-            self._tracer._send(
-                name=self._name,
-                input=state["input"],
-                error=str(error),
-                latency_ms=latency_ms,
-                framework="langchain",
-                model=state.get("model"),
-                tool_calls=state["tool_calls"] or None,
-                metadata=self._metadata,
-                session_id=self._session_id,
-                performance_summary=perf,
-                input_tokens=state["input_tokens"] or None,
-                output_tokens=state["output_tokens"] or None,
-            )
+            # See on_chain_end's matching branch — same standalone-usage handling.
+            with self._tracer.trace(self._name, metadata=self._metadata, session_id=self._session_id) as span:
+                span._start = state["start"]
+                span.set_error(str(error))
+                span._merge_child_run(
+                    execution_steps=state["execution_steps"],
+                    tool_calls=state["tool_calls"],
+                    retrieval_steps=state["retrieval_steps"],
+                    input=state["input"],
+                    model=state.get("model"),
+                    framework="langchain",
+                    input_tokens=state["input_tokens"] or None,
+                    output_tokens=state["output_tokens"] or None,
+                )
 
     # ------------------------------------------------------------------
     # LLM lifecycle
@@ -620,14 +607,6 @@ class AgentXCallbackHandler(BaseCallbackHandler):
         with self._state_lock:
             if top and top in self._runs:
                 self._runs[top]["tool_calls"].append(tool_call)
-                self._runs[top]["perf_tool_calls"].append({
-                    "name": state["tool_name"],
-                    "duration_ms": (end_t - start_t) * 1000,
-                    "start_time": start_t,
-                    "end_time": end_t,
-                    "input": state["tool_input"],
-                    "output": tool_call["output"],
-                })
 
     def on_tool_error(
         self,
@@ -656,14 +635,6 @@ class AgentXCallbackHandler(BaseCallbackHandler):
         with self._state_lock:
             if top and top in self._runs:
                 self._runs[top]["tool_calls"].append(tool_call)
-                self._runs[top]["perf_tool_calls"].append({
-                    "name": state.get("tool_name", "unknown"),
-                    "duration_ms": (end_t - start_t) * 1000,
-                    "start_time": start_t,
-                    "end_time": end_t,
-                    "input": tool_call["input"],
-                    "output": tool_call["output"],
-                })
 
     # ------------------------------------------------------------------
     # Retriever lifecycle