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

{agentx_python-0.6.12/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.12
+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

{agentx_python-0.6.12 → 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.12 → 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.12 → 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.12 → 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.12 → 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

{agentx_python-0.6.12 → agentx_python-0.6.13}/agentx/integrations/llamaindex.py

@@ -25,7 +25,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 llama_index.core.callbacks.base_handler import BaseCallbackHandler
@@ -278,25 +277,27 @@ class AgentXLlamaIndexHandler(BaseCallbackHandler):
         return None
 
     def _send_trace(self, state: Dict[str, Any]) -> None:
-        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["tool_call_steps"],
-            retrieval_steps=state["retrieval_steps"],
-            has_errors=state["error"] is not None,
-        )
-        self._tracer._send(
-            name=self._name,
-            input=state["input"],
-            output=state["output"],
-            latency_ms=latency_ms,
-            error=state["error"],
-            framework="llamaindex",
-            model=state["model"],
-            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,
-        )
+        # tool_call_steps entries carry start_time/end_time (unlike langchain.py's leaner
+        # wire-shaped tool_calls list) — _merge_child_run's tool_calls loop falls back to
+        # computing duration from those when no explicit latency_ms is present, so each tool
+        # call still positions correctly in the tree panel instead of defaulting to offset 0.
+        with self._tracer.trace(
+            self._name, metadata=self._metadata, session_id=self._session_id, framework="llamaindex"
+        ) as span:
+            # __enter__ just set _start to "now" — overridden to the query's real start time so
+            # __exit__'s latency_ms reflects the actual run, not the few microseconds between this
+            # trace()/with and its exit a couple lines below.
+            span._start = state["start"]
+            if state["error"]:
+                span.set_error(state["error"])
+            span._merge_child_run(
+                execution_steps=state["execution_steps"],
+                tool_calls=state["tool_call_steps"],
+                retrieval_steps=state["retrieval_steps"],
+                input=state["input"],
+                output=state["output"],
+                model=state["model"],
+                framework="llamaindex",
+                input_tokens=state["input_tokens"] or None,
+                output_tokens=state["output_tokens"] or None,
+            )