agentx-python 0.6.4__tar.gz → 0.6.6__tar.gz

{agentx_python-0.6.4/agentx_python.egg-info → agentx_python-0.6.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentx-python
-Version: 0.6.4
+Version: 0.6.6
 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
@@ -70,6 +70,7 @@ Also see [SDK Developer Docs](https://developers.agentx.so), [API Reference Docs
   - [Chat (streaming and non-streaming)](#chat-streaming-and-non-streaming)
 - [Workforce (multi-agent orchestration)](#workforce-multi-agent-orchestration) — teams of agents with a designated manager
 - [Production tracing](#production-tracing) — record live agent runs from any framework
+- [Monitor](#monitor) — automatic production monitoring, patterns and signals
 - [Custom agent evaluations](#custom-agent-evaluations) — LLM-as-a-judge, cosine / Jaccard similarity
 - [Links](#links)
 
@@ -245,6 +246,30 @@ See **[TRACING.md](TRACING.md)** for the complete guide — session grouping, er
 
 ---
 
+## Monitor
+
+Automatic production monitoring: check traces against detection patterns and get back triage-ready signals. A **pattern** is a first-class SDK resource with a real id, just like a `Dataset` or `EvaluationSettings`: create one once, then reference it by id at trace time.
+
+```python
+pattern = client.monitor.patterns.builder(
+    name="Promises a refund",
+    detector_kind="semantic",
+    semantic_prompt="The response promises a refund.",
+    severity="high",
+).publish()
+
+with client.tracer.trace("support-agent", monitor=True, pattern_ids=[pattern.id]) as span:
+    span.output = call_llm(query)
+```
+
+`monitor=True` checks the trace immediately, no dashboard setup required. `pattern_ids` restricts detection to exactly those patterns; omit it to run the full default sweep instead (built-in checks like empty response, trace error, and latency regression, plus every pattern enabled for the workspace).
+
+This works independently of the dashboard's per-agent monitoring toggle (Governance > Observe > Agents), which still auto-checks every trace from an agent once enabled there, with no code changes needed either way.
+
+See **[TRACING.md](TRACING.md)** for the complete Monitor guide.
+
+---
+
 ## Custom agent evaluations
 
 Evaluate **any** AI agent — LangChain, CrewAI, AutoGen, LlamaIndex, OpenAI, Anthropic, HTTP endpoints, or plain Python — using AgentX as the scoring and reporting backend. Includes optional **cosine** and **Jaccard** similarity metrics alongside LLM-graded ratings.
@@ -274,3 +299,4 @@ See **[EVALUATIONS.md](EVALUATIONS.md)** for the full guide — dataset builder,
 - **PyPI** — [agentx-python](https://pypi.org/project/agentx-python/)
 - **Tracing docs** — [TRACING.md](TRACING.md)
 - **Evaluations docs** — [EVALUATIONS.md](EVALUATIONS.md)
+- **Monitor docs** — [docs.agentx.so/sdk/monitor](https://docs.agentx.so/sdk/monitor)

{agentx_python-0.6.4 → agentx_python-0.6.6}/README.md

@@ -22,6 +22,7 @@ Also see [SDK Developer Docs](https://developers.agentx.so), [API Reference Docs
   - [Chat (streaming and non-streaming)](#chat-streaming-and-non-streaming)
 - [Workforce (multi-agent orchestration)](#workforce-multi-agent-orchestration) — teams of agents with a designated manager
 - [Production tracing](#production-tracing) — record live agent runs from any framework
+- [Monitor](#monitor) — automatic production monitoring, patterns and signals
 - [Custom agent evaluations](#custom-agent-evaluations) — LLM-as-a-judge, cosine / Jaccard similarity
 - [Links](#links)
 
@@ -197,6 +198,30 @@ See **[TRACING.md](TRACING.md)** for the complete guide — session grouping, er
 
 ---
 
+## Monitor
+
+Automatic production monitoring: check traces against detection patterns and get back triage-ready signals. A **pattern** is a first-class SDK resource with a real id, just like a `Dataset` or `EvaluationSettings`: create one once, then reference it by id at trace time.
+
+```python
+pattern = client.monitor.patterns.builder(
+    name="Promises a refund",
+    detector_kind="semantic",
+    semantic_prompt="The response promises a refund.",
+    severity="high",
+).publish()
+
+with client.tracer.trace("support-agent", monitor=True, pattern_ids=[pattern.id]) as span:
+    span.output = call_llm(query)
+```
+
+`monitor=True` checks the trace immediately, no dashboard setup required. `pattern_ids` restricts detection to exactly those patterns; omit it to run the full default sweep instead (built-in checks like empty response, trace error, and latency regression, plus every pattern enabled for the workspace).
+
+This works independently of the dashboard's per-agent monitoring toggle (Governance > Observe > Agents), which still auto-checks every trace from an agent once enabled there, with no code changes needed either way.
+
+See **[TRACING.md](TRACING.md)** for the complete Monitor guide.
+
+---
+
 ## Custom agent evaluations
 
 Evaluate **any** AI agent — LangChain, CrewAI, AutoGen, LlamaIndex, OpenAI, Anthropic, HTTP endpoints, or plain Python — using AgentX as the scoring and reporting backend. Includes optional **cosine** and **Jaccard** similarity metrics alongside LLM-graded ratings.
@@ -226,3 +251,4 @@ See **[EVALUATIONS.md](EVALUATIONS.md)** for the full guide — dataset builder,
 - **PyPI** — [agentx-python](https://pypi.org/project/agentx-python/)
 - **Tracing docs** — [TRACING.md](TRACING.md)
 - **Evaluations docs** — [EVALUATIONS.md](EVALUATIONS.md)
+- **Monitor docs** — [docs.agentx.so/sdk/monitor](https://docs.agentx.so/sdk/monitor)

{agentx_python-0.6.4 → agentx_python-0.6.6}/agentx/agentx.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import List, Optional
 import requests
 import os
 import logging
@@ -10,7 +10,12 @@ from agentx.resources.workforce import Workforce
 
 class AgentX:
 
-    def __init__(self, api_key: str = None, base_url: str = None, workspace_id: str = None):
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        workspace_id: Optional[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
@@ -24,6 +29,7 @@ class AgentX:
 
         from agentx.evaluations.client import EvaluationsClient
         from agentx.evaluations.runner import EvaluationsRunner
+        from agentx.monitor.client import MonitorClient
         from agentx.tracing.ingest_client import IngestClient
         from agentx.tracing.tracer import Tracer
         from agentx.version import VERSION
@@ -32,9 +38,19 @@ class AgentX:
             api_key=self.api_key,
             sdk_version=VERSION,
             base_url=self.base_url,
+            workspace_id=self.workspace_id,
         )
         self.evaluations = EvaluationsRunner(_eval_client)
 
+        # Monitor: create/reuse patterns (client.monitor.patterns) that a trace can be checked
+        # against at send time via tracer.trace(..., monitor=True, pattern_ids=[...]).
+        self.monitor = MonitorClient(
+            api_key=self.api_key,
+            sdk_version=VERSION,
+            base_url=self.base_url,
+            workspace_id=self.workspace_id,
+        )
+
         _ingest_client = IngestClient(
             api_key=self.api_key,
             sdk_version=VERSION,

agentx_python-0.6.6/agentx/evaluations/__init__.py

@@ -0,0 +1,7 @@
+from agentx.evaluations.client import EvaluationsClient
+from agentx.evaluations.evaluation_settings import (
+    EvaluationSettingsBuilder,
+    EvaluationSettingsClient,
+)
+
+__all__ = ["EvaluationsClient", "EvaluationSettingsBuilder", "EvaluationSettingsClient"]

{agentx_python-0.6.4 → agentx_python-0.6.6}/agentx/evaluations/client.py

@@ -13,6 +13,7 @@ from agentx.evaluations.models import (
     Dataset,
     EvaluationResult,
     EvaluationRun,
+    EvaluationSettings,
     EvaluationSubject,
     ModelInfo,
     Report,
@@ -44,12 +45,20 @@ class AgentXValidationError(AgentXEvaluationsError):
 
 class EvaluationsClient:
     def __init__(
-        self, api_key: str, sdk_version: str = "unknown", base_url: str = None
+        self,
+        api_key: str,
+        sdk_version: str = "unknown",
+        base_url: Optional[str] = None,
+        workspace_id: Optional[str] = None,
     ):
         if not api_key:
             raise AgentXAuthError("AGENTX_API_KEY is required")
         self._api_key = api_key
         self._sdk_version = sdk_version
+        # Falls back to the caller's default workspace server-side when unset — see
+        # _with_workspace(). Without this, dataset/settings/run creation silently land in
+        # whatever workspace the API key's user defaults to, not the one the caller intended.
+        self._workspace_id = workspace_id
         # Priority: constructor arg > env var > SDK default
         # Always append /custom-agent-evaluations so users only need to provide /api/v1
         _api_base = (
@@ -67,15 +76,29 @@ class EvaluationsClient:
                 "accept": "*/*",
             }
         )
-        # Expose dataset builder factory
+        # Expose dataset / evaluation-settings builder factories
         from agentx.evaluations.datasets import DatasetClient
+        from agentx.evaluations.evaluation_settings import EvaluationSettingsClient
 
         self.datasets = DatasetClient(self)
+        self.settings = EvaluationSettingsClient(self)
 
     # ------------------------------------------------------------------
     # Low-level HTTP
     # ------------------------------------------------------------------
 
+    def _with_workspace(self, payload: dict) -> dict:
+        """Injects the client's workspace_id into a request payload, unless the caller already
+        set one explicitly. Without this, requests silently fall back to the API key user's
+        default workspace server-side, which may not be the workspace the caller intended."""
+        if self._workspace_id and not payload.get("workspaceId"):
+            return {**payload, "workspaceId": self._workspace_id}
+        return payload
+
+    def _workspace_params(self) -> Optional[dict]:
+        """Same as _with_workspace(), for GET requests that take workspaceId as a query param."""
+        return {"workspaceId": self._workspace_id} if self._workspace_id else None
+
     def _request(self, method: str, path: str, timeout: int = 30, **kwargs) -> Any:
         url = f"{self._base_url}{path}"
         last_exc: Optional[Exception] = None
@@ -125,20 +148,52 @@ class EvaluationsClient:
     # ------------------------------------------------------------------
 
     def create_dataset(self, payload: dict) -> Dataset:
-        data = self._request("POST", "/datasets", json=payload)
+        data = self._request("POST", "/datasets", json=self._with_workspace(payload))
         return Dataset(**data)
 
     def list_datasets(self) -> List[Dataset]:
-        data = self._request("GET", "/datasets")
+        data = self._request("GET", "/datasets", params=self._workspace_params())
         return [
             Dataset(**d)
             for d in (data if isinstance(data, list) else data.get("datasets", []))
         ]
 
     def get_dataset(self, dataset_id: str) -> Dataset:
-        data = self._request("GET", f"/datasets/{dataset_id}")
+        data = self._request(
+            "GET", f"/datasets/{dataset_id}", params=self._workspace_params()
+        )
         return Dataset(**data)
 
+    # ------------------------------------------------------------------
+    # Evaluation Settings endpoints — standalone grading config, reusable
+    # across datasets.
+    # ------------------------------------------------------------------
+
+    def create_evaluation_settings(self, payload: dict) -> EvaluationSettings:
+        data = self._request(
+            "POST", "/evaluation-settings", json=self._with_workspace(payload)
+        )
+        return EvaluationSettings(**data)
+
+    def list_evaluation_settings(self) -> List[EvaluationSettings]:
+        data = self._request(
+            "GET", "/evaluation-settings", params=self._workspace_params()
+        )
+        return [
+            EvaluationSettings(**e)
+            for e in (
+                data if isinstance(data, list) else data.get("evaluationSettings", [])
+            )
+        ]
+
+    def get_evaluation_settings(self, evaluation_settings_id: str) -> EvaluationSettings:
+        data = self._request(
+            "GET",
+            f"/evaluation-settings/{evaluation_settings_id}",
+            params=self._workspace_params(),
+        )
+        return EvaluationSettings(**data)
+
     # ------------------------------------------------------------------
     # Run endpoints
     # ------------------------------------------------------------------
@@ -148,6 +203,7 @@ class EvaluationsClient:
         dataset_id: str,
         subject: EvaluationSubject,
         python_version: Optional[str] = None,
+        evaluation_settings_id: Optional[str] = None,
     ) -> EvaluationRun:
         from agentx.version import VERSION
 
@@ -162,7 +218,9 @@ class EvaluationsClient:
                 "pythonVersion": python_version or _python_version(),
             },
         }
-        data = self._request("POST", "/runs", json=payload)
+        if evaluation_settings_id:
+            payload["evaluationSettingsId"] = evaluation_settings_id
+        data = self._request("POST", "/runs", json=self._with_workspace(payload))
         return EvaluationRun(**data)
 
     def append_results(
@@ -207,6 +265,7 @@ def _result_to_payload(r: EvaluationResult) -> dict:
     d["questionIndex"] = d.pop("question_index", d.get("questionIndex"))
     d["runNumber"] = d.pop("run_number", d.get("runNumber"))
     d["idempotencyKey"] = d.pop("idempotency_key", d.get("idempotencyKey"))
+    d["traceId"] = d.pop("trace_id", d.get("traceId"))
     return {k: v for k, v in d.items() if v is not None}
 
 

{agentx_python-0.6.4 → agentx_python-0.6.6}/agentx/evaluations/datasets.py

@@ -29,6 +29,8 @@ class DatasetBuilder:
         evaluation_criteria: Optional[str] = None,
         vector_similarity: bool = False,
         jaccard_similarity: bool = False,
+        bleu_score: bool = False,
+        rouge_score: bool = False,
         similarity_model: Optional[str] = None,
         sovereignty_models: Optional[List[str]] = None,
     ):
@@ -43,7 +45,8 @@ class DatasetBuilder:
             "questions": [],
         }
         # Opt-in similarity metrics, surfaced on the report as cosine_similarity /
-        # jaccard_similarity (computed against each case's expected_results).
+        # jaccard_similarity / bleu_score / rouge_score (computed against each
+        # case's expected_results).
         if vector_similarity:
             vs: Dict[str, Any] = {"enabled": True}
             if similarity_model:
@@ -51,6 +54,10 @@ class DatasetBuilder:
             self._payload["vectorSimilarity"] = vs
         if jaccard_similarity:
             self._payload["jaccardSimilarity"] = {"enabled": True}
+        if bleu_score:
+            self._payload["bleuScore"] = {"enabled": True}
+        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).
         if sovereignty_models:
@@ -212,6 +219,8 @@ class DatasetClient:
         evaluation_criteria: Optional[str] = None,
         vector_similarity: bool = False,
         jaccard_similarity: bool = False,
+        bleu_score: bool = False,
+        rouge_score: bool = False,
         similarity_model: Optional[str] = None,
         sovereignty_models: Optional[List[str]] = None,
     ) -> DatasetBuilder:
@@ -225,6 +234,8 @@ class DatasetClient:
             evaluation_criteria=evaluation_criteria,
             vector_similarity=vector_similarity,
             jaccard_similarity=jaccard_similarity,
+            bleu_score=bleu_score,
+            rouge_score=rouge_score,
             similarity_model=similarity_model,
             sovereignty_models=sovereignty_models,
         )

agentx_python-0.6.6/agentx/evaluations/evaluation_settings.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional, TYPE_CHECKING
+
+from agentx.evaluations.models import EvaluationSettings
+
+if TYPE_CHECKING:
+    from agentx.evaluations.client import EvaluationsClient
+
+logger = logging.getLogger(__name__)
+
+
+class EvaluationSettingsBuilder:
+    """Fluent builder for creating a standalone, reusable grading config (no
+    dataset/questions attached)."""
+
+    def __init__(
+        self,
+        client: "EvaluationsClient",
+        name: str,
+        description: Optional[str] = None,
+        number_of_requests: int = 1,
+        acceptance_criteria: Optional[str] = None,
+        rejection_criteria: Optional[str] = None,
+        evaluation_criteria: Optional[str] = None,
+        vector_similarity: bool = False,
+        jaccard_similarity: bool = False,
+        bleu_score: bool = False,
+        rouge_score: bool = False,
+        similarity_model: Optional[str] = None,
+        sovereignty_models: Optional[List[str]] = None,
+    ):
+        self._client = client
+        self._payload: Dict[str, Any] = {
+            "name": name,
+            "description": description,
+            "numberOfRequests": number_of_requests,
+            "acceptanceCriteria": acceptance_criteria,
+            "rejectionCriteria": rejection_criteria,
+            "evaluationCriteria": evaluation_criteria,
+        }
+        # Opt-in similarity metrics, mirrors DatasetBuilder's config kwargs.
+        if vector_similarity:
+            vs: Dict[str, Any] = {"enabled": True}
+            if similarity_model:
+                vs["model"] = similarity_model
+            self._payload["vectorSimilarity"] = vs
+        if jaccard_similarity:
+            self._payload["jaccardSimilarity"] = {"enabled": True}
+        if bleu_score:
+            self._payload["bleuScore"] = {"enabled": True}
+        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).
+        if sovereignty_models:
+            self._payload["sovereigntyIndex"] = {
+                "enabled": True,
+                "models": list(sovereignty_models),
+            }
+
+    def publish(self) -> EvaluationSettings:
+        logger.info("Publishing evaluation settings '%s'", self._payload["name"])
+        return self._client.create_evaluation_settings(self._payload)
+
+
+class EvaluationSettingsClient:
+    """Thin wrapper surfaced as client.evaluations.settings."""
+
+    def __init__(self, client: "EvaluationsClient"):
+        self._client = client
+
+    def builder(
+        self,
+        name: str,
+        description: Optional[str] = None,
+        number_of_requests: int = 1,
+        acceptance_criteria: Optional[str] = None,
+        rejection_criteria: Optional[str] = None,
+        evaluation_criteria: Optional[str] = None,
+        vector_similarity: bool = False,
+        jaccard_similarity: bool = False,
+        bleu_score: bool = False,
+        rouge_score: bool = False,
+        similarity_model: Optional[str] = None,
+        sovereignty_models: Optional[List[str]] = None,
+    ) -> EvaluationSettingsBuilder:
+        return EvaluationSettingsBuilder(
+            self._client,
+            name=name,
+            description=description,
+            number_of_requests=number_of_requests,
+            acceptance_criteria=acceptance_criteria,
+            rejection_criteria=rejection_criteria,
+            evaluation_criteria=evaluation_criteria,
+            vector_similarity=vector_similarity,
+            jaccard_similarity=jaccard_similarity,
+            bleu_score=bleu_score,
+            rouge_score=rouge_score,
+            similarity_model=similarity_model,
+            sovereignty_models=sovereignty_models,
+        )
+
+    def get(self, evaluation_settings_id: str) -> EvaluationSettings:
+        return self._client.get_evaluation_settings(evaluation_settings_id)
+
+    def list(self) -> List[EvaluationSettings]:
+        return self._client.list_evaluation_settings()

{agentx_python-0.6.4 → agentx_python-0.6.6}/agentx/evaluations/models.py

@@ -76,6 +76,38 @@ class Dataset(BaseModel):
         extra = "ignore"
 
 
+class EvaluationSettings(BaseModel):
+    """A standalone, reusable grading config — no dataset/questions attached.
+    Created via ``client.evaluations.settings.builder(...).publish()`` and run
+    against any dataset by passing its id as ``evaluation_settings_id`` to
+    ``client.evaluations.run(...)``."""
+
+    id: str = Field(alias="_id")
+    name: str
+    description: Optional[str] = None
+    number_of_requests: int = Field(default=1, alias="numberOfRequests")
+    acceptance_criteria: Optional[str] = Field(default=None, alias="acceptanceCriteria")
+    rejection_criteria: Optional[str] = Field(default=None, alias="rejectionCriteria")
+    evaluation_criteria: Optional[str] = Field(default=None, alias="evaluationCriteria")
+    status: str = "published"
+    # Sovereignty & Portability — models selected to compare when this config runs.
+    # Hoisted from the nested ``sovereigntyIndex`` object when enabled.
+    sovereignty_models: List[str] = Field(default_factory=list)
+
+    @model_validator(mode="before")
+    @classmethod
+    def _extract_sovereignty_models(cls, data: Any) -> Any:
+        if isinstance(data, dict):
+            sov = data.get("sovereigntyIndex") or data.get("sovereignty_index") or {}
+            if isinstance(sov, dict) and sov.get("enabled") and sov.get("models"):
+                data = {**data, "sovereignty_models": list(sov.get("models") or [])}
+        return data
+
+    class Config:
+        populate_by_name = True
+        extra = "ignore"
+
+
 # ---------------------------------------------------------------------------
 # Evaluation subject
 # ---------------------------------------------------------------------------
@@ -154,6 +186,22 @@ class ServerLimits(BaseModel):
         extra = "ignore"
 
 
+class LiveStatistics(BaseModel):
+    """Rating aggregate computed server-side from submitted results — available
+    as soon as results are scored, independent of the `.analyze()` step (which
+    only adds the LLM-driven qualitative report). Returned on the run resource
+    (``GET /runs/:runId``) as ``liveStatistics``."""
+
+    average_rating: Optional[float] = Field(default=None, alias="averageRating")
+    min_rating: Optional[float] = Field(default=None, alias="minRating")
+    max_rating: Optional[float] = Field(default=None, alias="maxRating")
+    rated_count: int = Field(default=0, alias="ratedCount")
+
+    class Config:
+        populate_by_name = True
+        extra = "ignore"
+
+
 class EvaluationRun(BaseModel):
     run_id: str = Field(alias="runId")
     dataset_id: str = Field(alias="datasetId")
@@ -226,6 +274,10 @@ class EvaluationResult(BaseModel):
     timings: Optional[ResultTimings] = None
     metadata: Optional[Dict[str, Any]] = None
     idempotency_key: Optional[str] = Field(default=None, alias="idempotencyKey")
+    # Links this result to a PromptTrace ingested via client.tracer.trace(..., sync=True) — lets
+    # the dashboard's "Message Trace Details -> Execution Timeline" render the full execution
+    # trace for this case, not just the lightweight observable_trace events above.
+    trace_id: Optional[str] = Field(default=None, alias="traceId")
 
     class Config:
         populate_by_name = True
@@ -262,6 +314,8 @@ class BatchAppendResponse(BaseModel):
     scored_results: List[ScoredResult] = Field(
         default_factory=list, alias="scoredResults"
     )
+    # Server-computed rating aggregate, refreshed after this batch — see LiveStatistics.
+    live_statistics: Optional[LiveStatistics] = Field(default=None, alias="liveStatistics")
 
     class Config:
         populate_by_name = True
@@ -280,6 +334,8 @@ class ReportStatistics(BaseModel):
     max_rating: float = Field(default=0.0, alias="maxRating")
     cosine_similarity: Optional[float] = Field(default=None, alias="cosineSimilarity")
     jaccard_similarity: Optional[float] = Field(default=None, alias="jaccardSimilarity")
+    bleu_score: Optional[float] = Field(default=None, alias="bleuScore")
+    rouge_score: Optional[float] = Field(default=None, alias="rougeScore")
 
     class Config:
         populate_by_name = True
@@ -356,6 +412,12 @@ class SovereigntyModelMetrics(BaseModel):
     average_jaccard_similarity: Optional[float] = Field(
         default=None, alias="averageJaccardSimilarity"
     )
+    average_bleu_score: Optional[float] = Field(
+        default=None, alias="averageBleuScore"
+    )
+    average_rouge_score: Optional[float] = Field(
+        default=None, alias="averageRougeScore"
+    )
     average_latency_ms: Optional[float] = Field(default=None, alias="averageLatencyMs")
     total_input_tokens: Optional[int] = Field(default=None, alias="totalInputTokens")
     total_output_tokens: Optional[int] = Field(default=None, alias="totalOutputTokens")
@@ -421,11 +483,15 @@ class Report(BaseModel):
             return data
         stats = data.get("statistics")
         stats = dict(stats) if isinstance(stats, dict) else {}
-        for top_key, nested_key in (
-            ("cosineSimilarity", "cosineSimilarity"),
-            ("cosine_similarity", "cosine_similarity"),
-            ("jaccardSimilarity", "jaccardSimilarity"),
-            ("jaccard_similarity", "jaccard_similarity"),
+        for top_key, nested_key, marker in (
+            ("cosineSimilarity", "cosineSimilarity", "cosine"),
+            ("cosine_similarity", "cosine_similarity", "cosine"),
+            ("jaccardSimilarity", "jaccardSimilarity", "jaccard"),
+            ("jaccard_similarity", "jaccard_similarity", "jaccard"),
+            ("bleuScore", "bleuScore", "bleu"),
+            ("bleu_score", "bleu_score", "bleu"),
+            ("rougeScore", "rougeScore", "rouge"),
+            ("rouge_score", "rouge_score", "rouge"),
         ):
             top_val = data.get(top_key)
             if top_val is None:
@@ -433,15 +499,19 @@ class Report(BaseModel):
             if (
                 stats.get("cosineSimilarity") is None
                 and stats.get("cosine_similarity") is None
-                and "cosine" in nested_key.lower()
+                and marker == "cosine"
             ):
                 stats[nested_key] = top_val
             if (
                 stats.get("jaccardSimilarity") is None
                 and stats.get("jaccard_similarity") is None
-                and "jaccard" in nested_key.lower()
+                and marker == "jaccard"
             ):
                 stats[nested_key] = top_val
+            if stats.get("bleuScore") is None and stats.get("bleu_score") is None and marker == "bleu":
+                stats[nested_key] = top_val
+            if stats.get("rougeScore") is None and stats.get("rouge_score") is None and marker == "rouge":
+                stats[nested_key] = top_val
         if stats:
             data["statistics"] = stats
         return data
@@ -462,6 +532,18 @@ class Report(BaseModel):
             self.statistics.jaccard_similarity if self.statistics is not None else None
         )
 
+    @property
+    def bleu_score(self) -> Optional[float]:
+        """Average BLEU score across scored results, or ``None`` if the metric
+        was not enabled for the dataset or no result has a value yet."""
+        return self.statistics.bleu_score if self.statistics is not None else None
+
+    @property
+    def rouge_score(self) -> Optional[float]:
+        """Average ROUGE-L (F1) score across scored results, or ``None`` if the
+        metric was not enabled for the dataset or no result has a value yet."""
+        return self.statistics.rouge_score if self.statistics is not None else None
+
     @property
     def average_rating(self) -> Optional[float]:
         """Convenience accessor matching cosine_similarity / jaccard_similarity."""

{agentx_python-0.6.4 → agentx_python-0.6.6}/agentx/evaluations/reporting.py

@@ -67,6 +67,20 @@ def print_report(report: Report) -> None:
             f"  {dim('Jaccard :')} {jac_color(f'{jac * 100:.1f}%')}  {dim('(token-set overlap)')}"
         )
 
+    bleu = report.bleu_score
+    if bleu is not None:
+        bleu_color = green if bleu >= 0.6 else (yellow if bleu >= 0.3 else red)
+        print(
+            f"  {dim('BLEU    :')} {bleu_color(f'{bleu * 100:.1f}%')}  {dim('(n-gram precision)')}"
+        )
+
+    rouge = report.rouge_score
+    if rouge is not None:
+        rouge_color = green if rouge >= 0.6 else (yellow if rouge >= 0.3 else red)
+        print(
+            f"  {dim('ROUGE-L :')} {rouge_color(f'{rouge * 100:.1f}%')}  {dim('(longest common subsequence)')}"
+        )
+
     if report.consistency_score is not None:
         cs = report.consistency_score
         cs_color = green if cs >= 7 else (yellow if cs >= 4 else red)

{agentx_python-0.6.4 → agentx_python-0.6.6}/agentx/evaluations/results.py

@@ -34,6 +34,7 @@ def normalize_result(
 
     output: Optional[dict] = None
     trace = None
+    trace_id: Optional[str] = None
     metadata: Optional[dict] = None
     error: Optional[ResultError] = None
     input_tokens: Optional[int] = None
@@ -50,6 +51,8 @@ def normalize_result(
             output = {"text": str(text)} if text else None
 
         trace = build_trace(raw.get("trace") or raw.get("observable_trace"))
+        trace_id_raw = raw.get("trace_id") or raw.get("traceId")
+        trace_id = str(trace_id_raw) if trace_id_raw else None
         meta_raw = raw.get("metadata")
         if isinstance(meta_raw, dict):
             metadata = redact_dict(meta_raw)
@@ -102,6 +105,7 @@ def normalize_result(
             else None
         ),
         metadata=metadata,
+        traceId=trace_id,
     )