agentx-python 0.4.12__py3-none-any.whl → 0.4.14__py3-none-any.whl

agentx/agentx.py

@@ -10,7 +10,7 @@ from agentx.resources.workforce import Workforce
 
 class AgentX:
 
-    def __init__(self, api_key: str = None, base_url: str = None):
+    def __init__(self, api_key: str = None, base_url: str = None, workspace_id: str = None):
         self.api_key = api_key or os.getenv("AGENTX_API_KEY")
         if self.api_key and not os.getenv("AGENTX_API_KEY"):
             os.environ["AGENTX_API_KEY"] = self.api_key
@@ -20,6 +20,8 @@ class AgentX:
         if self.base_url:
             os.environ["AGENTX_API_BASE_URL"] = self.base_url
 
+        self.workspace_id = workspace_id or os.getenv("AGENTX_WORKSPACE_ID")
+
         from agentx.evaluations.client import EvaluationsClient
         from agentx.evaluations.runner import EvaluationsRunner
         from agentx.tracing.ingest_client import IngestClient
@@ -37,6 +39,7 @@ class AgentX:
             api_key=self.api_key,
             sdk_version=VERSION,
             base_url=self.base_url,
+            workspace_id=self.workspace_id,
         )
         self.tracer = Tracer(_ingest_client)
 

agentx/integrations/openai_agents.py

@@ -11,22 +11,111 @@ Usage::
     from agents import add_trace_processor
     add_trace_processor(processor)
 
-Requires: ``pip install agentx[openai-agents]``
+Requires: ``pip install "agentx-python[openai-agents]"``
 """
 from __future__ import annotations
 
 import time
-from typing import Any, Dict, Optional
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
 
 from agentx.tracing.tracer import Tracer, _safe_serialize
 
 
+def _iso_to_ts(iso: Optional[str]) -> Optional[float]:
+    """Parse an ISO-8601 timestamp string to a Unix timestamp float."""
+    if not iso:
+        return None
+    try:
+        return datetime.fromisoformat(iso.replace("Z", "+00:00")).timestamp()
+    except Exception:
+        return None
+
+
+def _span_latency_ms(span: Any) -> Optional[int]:
+    """Return span duration in ms from ISO started_at / ended_at strings."""
+    t0 = _iso_to_ts(getattr(span, "started_at", None))
+    t1 = _iso_to_ts(getattr(span, "ended_at", None))
+    if t0 is not None and t1 is not None:
+        return max(0, int((t1 - t0) * 1000))
+    return None
+
+
+def _extract_text(output: Any) -> Optional[str]:
+    """
+    Best-effort extraction of a human-readable string from a GenerationSpanData
+    or ResponseSpanData output, which can be a list of message dicts in either
+    the Chat Completions or Responses API format.
+    """
+    if output is None:
+        return None
+    if isinstance(output, str):
+        return output
+    if not isinstance(output, (list, tuple)):
+        return _safe_serialize(output)
+
+    for item in reversed(output):
+        if not isinstance(item, dict):
+            # Could be a pydantic model — try .text or .content
+            text = getattr(item, "text", None) or getattr(item, "content", None)
+            if text and isinstance(text, str):
+                return text
+            continue
+
+        # Responses API: {"type": "message", "content": [{"type": "output_text", "text": "..."}]}
+        if item.get("type") == "message":
+            content = item.get("content", [])
+            if isinstance(content, list):
+                for part in content:
+                    if isinstance(part, dict) and part.get("type") == "output_text":
+                        return part.get("text")
+
+        # Chat Completions API: {"role": "assistant", "content": "..."}
+        role = item.get("role", "")
+        if role == "assistant":
+            content = item.get("content")
+            if isinstance(content, str):
+                return content
+            if isinstance(content, list):
+                for part in content:
+                    if isinstance(part, dict) and part.get("type") == "text":
+                        return part.get("text")
+
+    return _safe_serialize(output)
+
+
+def _extract_input_text(input_data: Any) -> Optional[str]:
+    """Extract the user's input query from a generation span's input messages."""
+    if input_data is None:
+        return None
+    if isinstance(input_data, str):
+        return input_data
+    if not isinstance(input_data, (list, tuple)):
+        return _safe_serialize(input_data)
+
+    # Walk messages and grab the last user message content
+    user_text = None
+    for item in input_data:
+        if not isinstance(item, dict):
+            continue
+        if item.get("role") == "user":
+            content = item.get("content")
+            if isinstance(content, str):
+                user_text = content
+            elif isinstance(content, list):
+                for part in content:
+                    if isinstance(part, dict) and part.get("type") in ("text", "input_text"):
+                        user_text = part.get("text")
+
+    return user_text or _safe_serialize(input_data)
+
+
 class AgentXTracingProcessor:
     """
     Implements the ``TracingProcessor`` interface expected by the OpenAI Agents SDK
     (``agents.add_trace_processor``).
 
-    Sends one AgentX trace per top-level agent run span.
+    Sends one AgentX trace per top-level agent run.
     """
 
     def __init__(
@@ -38,7 +127,7 @@ class AgentXTracingProcessor:
         self._tracer = tracer
         self._metadata = metadata
         self._session_id = session_id
-        # span_id → state for in-flight agent spans
+        # trace_id → accumulated state
         self._spans: Dict[str, Dict[str, Any]] = {}
 
     # ------------------------------------------------------------------
@@ -46,18 +135,17 @@ class AgentXTracingProcessor:
     # ------------------------------------------------------------------
 
     def on_trace_start(self, trace: Any) -> None:
-        """Called when a new trace (top-level run) begins."""
         trace_id = getattr(trace, "trace_id", None) or str(id(trace))
         self._spans[trace_id] = {
             "start": time.time(),
             "name": getattr(trace, "name", "openai-agent"),
             "input": None,
+            "output": None,
             "tool_calls": [],
             "model": None,
         }
 
     def on_trace_end(self, trace: Any) -> None:
-        """Called when the trace ends (agent run complete)."""
         trace_id = getattr(trace, "trace_id", None) or str(id(trace))
         state = self._spans.pop(trace_id, None)
         if state is None:
@@ -66,7 +154,7 @@ class AgentXTracingProcessor:
         self._tracer._send(
             name=state["name"],
             input=state.get("input"),
-            output=_safe_serialize(getattr(trace, "output", None)),
+            output=state.get("output"),
             latency_ms=latency_ms,
             framework="openai-agents",
             model=state.get("model"),
@@ -76,47 +164,58 @@ class AgentXTracingProcessor:
         )
 
     def on_span_start(self, span: Any) -> None:
-        """Called for each nested span (LLM call, tool call, etc.)."""
-        span_type = getattr(span, "span_data", None)
-        if span_type is None:
-            return
-
-        # Capture model from LLM generation spans
-        if hasattr(span_type, "model"):
-            trace_id = getattr(span, "trace_id", None)
-            if trace_id and trace_id in self._spans and not self._spans[trace_id].get("model"):
-                self._spans[trace_id]["model"] = str(span_type.model)
-
-        # Capture input on the root span
-        if hasattr(span_type, "input") and span_type.input:
-            trace_id = getattr(span, "trace_id", None)
-            if trace_id and trace_id in self._spans and not self._spans[trace_id].get("input"):
-                self._spans[trace_id]["input"] = _safe_serialize(span_type.input)
+        pass  # All data is captured in on_span_end when fields are fully populated
 
     def on_span_end(self, span: Any) -> None:
-        """Called when a nested span ends; captures tool-call results."""
         span_data = getattr(span, "span_data", None)
         if span_data is None:
             return
 
-        # Tool / function calls
-        if hasattr(span_data, "tool_name") or hasattr(span_data, "name"):
-            trace_id = getattr(span, "trace_id", None)
-            if trace_id and trace_id in self._spans:
-                tool_entry: Dict[str, Any] = {
-                    "name": getattr(span_data, "tool_name", None)
-                    or getattr(span_data, "name", "tool"),
-                    "input": _safe_serialize(getattr(span_data, "input", None)),
-                    "output": str(getattr(span_data, "output", ""))[:500],
-                }
-                if hasattr(span, "started_at") and hasattr(span, "ended_at"):
-                    try:
-                        tool_entry["latency_ms"] = int(
-                            (span.ended_at - span.started_at) * 1000
-                        )
-                    except Exception:
-                        pass
-                self._spans[trace_id]["tool_calls"].append(tool_entry)
+        trace_id = getattr(span, "trace_id", None)
+        if not trace_id or trace_id not in self._spans:
+            return
+
+        state = self._spans[trace_id]
+        span_type = getattr(span_data, "type", None)
+
+        if span_type == "generation":
+            # Capture input from the first generation span
+            if state["input"] is None and span_data.input:
+                state["input"] = _extract_input_text(span_data.input)
+            # Always update output to the latest generation (last one wins = final reply)
+            if span_data.output:
+                state["output"] = _extract_text(span_data.output)
+            # Capture model name
+            if not state["model"] and span_data.model:
+                state["model"] = str(span_data.model)
+
+        elif span_type == "response":
+            # Responses API path — extract from the response object
+            response = getattr(span_data, "response", None)
+            if response is not None:
+                if state["input"] is None:
+                    raw_input = getattr(span_data, "input", None)
+                    if raw_input:
+                        state["input"] = _extract_input_text(raw_input) if isinstance(raw_input, list) else str(raw_input)
+                output_items = getattr(response, "output", None)
+                if output_items:
+                    state["output"] = _extract_text(output_items)
+                if not state["model"]:
+                    model = getattr(response, "model", None)
+                    if model:
+                        state["model"] = str(model)
+
+        elif span_type == "function":
+            # Tool / function call
+            tool_entry: Dict[str, Any] = {
+                "name": span_data.name,
+                "input": span_data.input,
+                "output": str(span_data.output)[:500] if span_data.output is not None else None,
+            }
+            latency = _span_latency_ms(span)
+            if latency is not None:
+                tool_entry["latency_ms"] = latency
+            state["tool_calls"].append(tool_entry)
 
     def force_flush(self) -> None:
         self._tracer.flush()

agentx/tracing/ingest_client.py

@@ -41,10 +41,13 @@ class IngestClient:
         api_key: str,
         sdk_version: str = "unknown",
         base_url: Optional[str] = None,
+        workspace_id: Optional[str] = None,
     ) -> None:
         if not api_key:
             raise ValueError("AGENTX_API_KEY is required")
 
+        self._workspace_id = workspace_id or os.getenv("AGENTX_WORKSPACE_ID")
+
         self._api_key = api_key
         self._sdk_version = sdk_version
 
@@ -76,6 +79,8 @@ class IngestClient:
 
     def enqueue(self, payload: Dict[str, Any]) -> None:
         """Add a trace payload to the send queue. Never blocks; drops silently on overflow."""
+        if self._workspace_id:
+            payload = {**payload, "workspaceId": self._workspace_id}
         try:
             self._queue.put_nowait(payload)
         except queue.Full:
@@ -105,6 +110,8 @@ class IngestClient:
         payload: Dict[str, Any] = {"datasetId": dataset_id}
         if question_index is not None:
             payload["question_index"] = question_index
+        if self._workspace_id:
+            payload["workspaceId"] = self._workspace_id
 
         resp = self._session.post(url, json=payload, timeout=60)
         resp.raise_for_status()
@@ -131,8 +138,9 @@ class IngestClient:
             payload["pass_rate_threshold"] = pass_rate_threshold
         if git_context:
             payload["git_context"] = git_context
-        if workspace_id:
-            payload["workspaceId"] = workspace_id
+        resolved_workspace = workspace_id or self._workspace_id
+        if resolved_workspace:
+            payload["workspaceId"] = resolved_workspace
 
         url = f"{self._base_url}/ingest/ci-runs"
         resp = self._session.post(url, json=payload, timeout=30)
@@ -212,8 +220,9 @@ class IngestClient:
     ) -> Dict[str, Any]:
         """Fetch test case queries for a dataset without creating a CI run."""
         params: Dict[str, str] = {}
-        if workspace_id:
-            params["workspaceId"] = workspace_id
+        resolved_workspace = workspace_id or self._workspace_id
+        if resolved_workspace:
+            params["workspaceId"] = resolved_workspace
         url = f"{self._base_url}/ingest/datasets/{dataset_id}/test-cases"
         resp = self._session.get(url, params=params, timeout=15)
         self._raise_for_ci_status(resp)

agentx/version.py

@@ -1 +1 @@
-VERSION = "0.4.12"
+VERSION = "0.4.14"

{agentx_python-0.4.12.dist-info → agentx_python-0.4.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentx-python
-Version: 0.4.12
+Version: 0.4.14
 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
@@ -14,8 +14,7 @@ License-File: LICENSE
 Requires-Dist: urllib3>=1.26.11
 Requires-Dist: certifi
 Requires-Dist: requests
-Requires-Dist: pydantic
-Requires-Dist: pydantic_core
+Requires-Dist: pydantic>=2.0.0
 Provides-Extra: langchain
 Requires-Dist: langchain-core>=0.1.0; extra == "langchain"
 Provides-Extra: crewai

{agentx_python-0.4.12.dist-info → agentx_python-0.4.14.dist-info}/RECORD

@@ -1,8 +1,8 @@
 agentx/__init__.py,sha256=4iMiGLNU4S-I-WyX0Z7l0BFUY_krVJ3seMQPqyO-ReA,602
-agentx/agentx.py,sha256=rWfeFBS4wV7b9HzJlkO651pgPWo58tZFmPDgPfq6eQo,3321
+agentx/agentx.py,sha256=tw3CUnkvTM1eopoO7u8TgKnAz9t0HNSxrVcjIJsytAg,3469
 agentx/exceptions.py,sha256=TKooc1_pQ2P_4DqpLfZx_ap-6cfrjFLW8JS2qaGx_1M,1237
 agentx/util.py,sha256=yOV3VVdc0KUbw5pEkSRiO2lZzEtL1vOsnB_f5tFk948,665
-agentx/version.py,sha256=M4jHf2piUpaEzqXOe34S2F5941xUUdbYw1L0mpXlyj8,19
+agentx/version.py,sha256=_pWcb0KD7RwUQ8uiQjs-gUiG1ej2mVAyGLgZjVwFiUc,19
 agentx/evaluations/__init__.py,sha256=OmdCHiBO3Qcsck0UkOyVqSvfRs6nXbSi-2FXzyRfsog,89
 agentx/evaluations/_term.py,sha256=S4blZgH66wHvkt2hR29h8JE5xnakBeD7dlZdUW9Wfoo,2065
 agentx/evaluations/client.py,sha256=3mC0uSBRk9uO4F3a7kIMM_UUsyypF99_97E5MSpYFzM,7736
@@ -21,17 +21,17 @@ agentx/integrations/__init__.py,sha256=ZKOwYsvHXo9ipJUv5rPF1DOA0H5Q5YBG0WRI1f0lv
 agentx/integrations/anthropic.py,sha256=VzRdeICYm_zfgNBy6PEu6bYSUa9iKuSoRX6HSivWQpM,4802
 agentx/integrations/crewai.py,sha256=o7tgFE1I2T7fxOc2lG7aY1nAAwihejV3y-EJII6z1j0,3488
 agentx/integrations/langchain.py,sha256=_W62CUnzqlzSgIcNim0xDGXc3WsPoWYLQSHpTD4Xp5E,7844
-agentx/integrations/openai_agents.py,sha256=XDN_tNfx1ztLUlwNHgFk6QSiYbUDLo-HPljrHjZoVWk,4668
+agentx/integrations/openai_agents.py,sha256=JscJELxs8sTj3toi9ixY5TOpH-lCVBtpgxYgahIaezE,8162
 agentx/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 agentx/resources/agent.py,sha256=ZKpxDYzJbKgOX4-W86U__b4gko7XlbwB4q6L8Az9uo0,2011
 agentx/resources/conversation.py,sha256=HK7gEGK6qIUz0KvG-ItUip08otWZdkP5S6qHiznvgZM,4443
 agentx/resources/workforce.py,sha256=lfGVkoV9lcOp-lZScjTvwRarJMkhzfMfLm4syJDujGc,4168
 agentx/tracing/__init__.py,sha256=l2mIRILE-wWrCD0fekgrIOQUEvtDObzdrkgpQUtXroU,408
 agentx/tracing/ci_types.py,sha256=zFVcZGvc1qbVDdOlEPQ1i5R6terqJHxCzFF4ZjouxxI,1423
-agentx/tracing/ingest_client.py,sha256=p-rqzYEvFgUwRIcY54omXz4tPvw-hHzysVCCA2PSpuo,11025
+agentx/tracing/ingest_client.py,sha256=8aLabvWecgZsn0pkajZkI1it2TOk5boP0kC3o6TO52o,11487
 agentx/tracing/tracer.py,sha256=nJILoeQg6HV4SR05xJPy6EiSiZCpkp4yFBTrN1BO_1w,16951
-agentx_python-0.4.12.dist-info/licenses/LICENSE,sha256=6ZbiPNFmv3xBb44LGhAa3PZYK0ROAztsd5LRFZDlGFE,1074
-agentx_python-0.4.12.dist-info/METADATA,sha256=l_nlLJPCx7NjWvDOlJXEmDlG8m0U9QxJ1eJBOkPDg1U,6652
-agentx_python-0.4.12.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-agentx_python-0.4.12.dist-info/top_level.txt,sha256=s-q-HB9Gb_QdrZNacSeQyF_c25gQooMy7DlxzgLOHPk,7
-agentx_python-0.4.12.dist-info/RECORD,,
+agentx_python-0.4.14.dist-info/licenses/LICENSE,sha256=6ZbiPNFmv3xBb44LGhAa3PZYK0ROAztsd5LRFZDlGFE,1074
+agentx_python-0.4.14.dist-info/METADATA,sha256=b2VooejMy2en_rD9tGJhcHLdrzmuC2Tx5gjfSEKYsi8,6630
+agentx_python-0.4.14.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+agentx_python-0.4.14.dist-info/top_level.txt,sha256=s-q-HB9Gb_QdrZNacSeQyF_c25gQooMy7DlxzgLOHPk,7
+agentx_python-0.4.14.dist-info/RECORD,,