agentx-python 0.4.9__py3-none-any.whl → 0.4.10__py3-none-any.whl

agentx/agentx.py

@@ -23,6 +23,7 @@ class AgentX:
         from agentx.evaluations.client import EvaluationsClient
         from agentx.evaluations.runner import EvaluationsRunner
         from agentx.version import VERSION
+
         _eval_client = EvaluationsClient(
             api_key=self.api_key,
             sdk_version=VERSION,

agentx/evaluations/_term.py

@@ -1,4 +1,5 @@
 """Minimal ANSI terminal helpers — no external dependencies."""
+
 from __future__ import annotations
 
 import itertools
@@ -13,23 +14,42 @@ def _c(code: str) -> str:
     return f"\033[{code}m" if _IS_TTY else ""
 
 
-RESET  = _c("0")
-BOLD   = _c("1")
-DIM    = _c("2")
-GREEN  = _c("32")
+RESET = _c("0")
+BOLD = _c("1")
+DIM = _c("2")
+GREEN = _c("32")
 YELLOW = _c("33")
-RED    = _c("31")
-CYAN   = _c("36")
+RED = _c("31")
+CYAN = _c("36")
 MAGENTA = _c("35")
 
 
-def green(s: str) -> str:   return f"{GREEN}{s}{RESET}"
-def yellow(s: str) -> str:  return f"{YELLOW}{s}{RESET}"
-def red(s: str) -> str:     return f"{RED}{s}{RESET}"
-def cyan(s: str) -> str:    return f"{CYAN}{s}{RESET}"
-def bold(s: str) -> str:    return f"{BOLD}{s}{RESET}"
-def dim(s: str) -> str:     return f"{DIM}{s}{RESET}"
-def magenta(s: str) -> str: return f"{MAGENTA}{s}{RESET}"
+def green(s: str) -> str:
+    return f"{GREEN}{s}{RESET}"
+
+
+def yellow(s: str) -> str:
+    return f"{YELLOW}{s}{RESET}"
+
+
+def red(s: str) -> str:
+    return f"{RED}{s}{RESET}"
+
+
+def cyan(s: str) -> str:
+    return f"{CYAN}{s}{RESET}"
+
+
+def bold(s: str) -> str:
+    return f"{BOLD}{s}{RESET}"
+
+
+def dim(s: str) -> str:
+    return f"{DIM}{s}{RESET}"
+
+
+def magenta(s: str) -> str:
+    return f"{MAGENTA}{s}{RESET}"
 
 
 class Spinner:
@@ -64,6 +84,8 @@ class Spinner:
         for frame in itertools.cycle(self._FRAMES):
             if self._stop.is_set():
                 break
-            sys.stdout.write(f"\r  {CYAN}{frame}{RESET}  {self._message}  {DIM}(this may take ~60s+){RESET}")
+            sys.stdout.write(
+                f"\r  {CYAN}{frame}{RESET}  {self._message}  {DIM}(this may take ~60s+){RESET}"
+            )
             sys.stdout.flush()
             time.sleep(0.08)

agentx/evaluations/adapters/precomputed.py

@@ -27,7 +27,9 @@ class PrecomputedAdapter:
             self._lookup = {str(k): v for k, v in outputs.items()}
 
     def run(self, case: EvaluationCase) -> EvaluationResult:
-        raw = self._lookup.get(case.case_id) or self._lookup.get(str(case.question_index))
+        raw = self._lookup.get(case.case_id) or self._lookup.get(
+            str(case.question_index)
+        )
         if raw is None:
             raw = ""
         return normalize_result(case, raw, latency_ms=0)

agentx/evaluations/adapters/raw.py

@@ -23,8 +23,11 @@ class RawCallableAdapter:
     def __init__(self, fn: Callable[[EvaluationCase], Any]):
         self._fn = fn
 
-    def run(self, case: EvaluationCase, latency_ms: int | None = None) -> EvaluationResult:
+    def run(
+        self, case: EvaluationCase, latency_ms: int | None = None
+    ) -> EvaluationResult:
         import time
+
         start = time.monotonic()
         try:
             raw = self._fn(case)

agentx/evaluations/client.py

@@ -42,26 +42,33 @@ class AgentXValidationError(AgentXEvaluationsError):
 
 
 class EvaluationsClient:
-    def __init__(self, api_key: str, sdk_version: str = "unknown", base_url: str = None):
+    def __init__(
+        self, api_key: str, sdk_version: str = "unknown", base_url: str = None
+    ):
         if not api_key:
             raise AgentXAuthError("AGENTX_API_KEY is required")
         self._api_key = api_key
         self._sdk_version = sdk_version
         # Priority: constructor arg > env var > SDK default
         # Always append /custom-agent-evaluations so users only need to provide /api/v1
-        _api_base = (base_url or os.getenv("AGENTX_API_BASE_URL", _UTIL_API_BASE)).rstrip("/")
+        _api_base = (
+            base_url or os.getenv("AGENTX_API_BASE_URL", _UTIL_API_BASE)
+        ).rstrip("/")
         if not _api_base.endswith("/custom-agent-evaluations"):
             _api_base = f"{_api_base}/custom-agent-evaluations"
         self._base_url = _api_base
         self._session = requests.Session()
-        self._session.headers.update({
-            "x-api-key": self._api_key,
-            "Content-Type": "application/json",
-            "User-Agent": f"{SDK_NAME}/{self._sdk_version}",
-            "accept": "*/*",
-        })
+        self._session.headers.update(
+            {
+                "x-api-key": self._api_key,
+                "Content-Type": "application/json",
+                "User-Agent": f"{SDK_NAME}/{self._sdk_version}",
+                "accept": "*/*",
+            }
+        )
         # Expose dataset builder factory
         from agentx.evaluations.datasets import DatasetClient
+
         self.datasets = DatasetClient(self)
 
     # ------------------------------------------------------------------
@@ -86,7 +93,9 @@ class EvaluationsClient:
             if resp.status_code == 422:
                 raise AgentXValidationError(resp.text)
             if resp.status_code in _RETRYABLE_STATUS and attempt < _MAX_RETRIES - 1:
-                logger.debug("Retryable status %d (attempt %d)", resp.status_code, attempt + 1)
+                logger.debug(
+                    "Retryable status %d (attempt %d)", resp.status_code, attempt + 1
+                )
                 last_exc = AgentXEvaluationsError(f"HTTP {resp.status_code}")
                 continue
             if not resp.ok:
@@ -107,7 +116,10 @@ class EvaluationsClient:
 
     def list_datasets(self) -> List[Dataset]:
         data = self._request("GET", "/datasets")
-        return [Dataset(**d) for d in (data if isinstance(data, list) else data.get("datasets", []))]
+        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}")
@@ -124,6 +136,7 @@ class EvaluationsClient:
         python_version: Optional[str] = None,
     ) -> EvaluationRun:
         from agentx.version import VERSION
+
         payload = {
             "datasetId": dataset_id,
             "evaluationSubject": subject.model_dump(by_alias=True, exclude_none=True),
@@ -138,7 +151,9 @@ class EvaluationsClient:
         data = self._request("POST", "/runs", json=payload)
         return EvaluationRun(**data)
 
-    def append_results(self, run_id: str, batch_id: str, results: List[EvaluationResult]) -> BatchAppendResponse:
+    def append_results(
+        self, run_id: str, batch_id: str, results: List[EvaluationResult]
+    ) -> BatchAppendResponse:
         payload = {
             "batchId": batch_id,
             "results": [_result_to_payload(r) for r in results],
@@ -147,7 +162,9 @@ class EvaluationsClient:
         return BatchAppendResponse(**data)
 
     def finalize_run(self, run_id: str) -> Dict[str, Any]:
-        return self._request("POST", f"/runs/{run_id}/finalize", json={"status": "completed"})
+        return self._request(
+            "POST", f"/runs/{run_id}/finalize", json={"status": "completed"}
+        )
 
     def analyze_run(self, run_id: str) -> Dict[str, Any]:
         return self._request("POST", f"/runs/{run_id}/analyze", json={}, timeout=300)
@@ -168,6 +185,7 @@ class EvaluationsClient:
 # Helpers
 # ---------------------------------------------------------------------------
 
+
 def _result_to_payload(r: EvaluationResult) -> dict:
     d = r.model_dump(by_alias=True, exclude_none=True)
     # Rename snake_case fields the model may have stored locally
@@ -180,4 +198,5 @@ def _result_to_payload(r: EvaluationResult) -> dict:
 
 def _python_version() -> str:
     import sys
+
     return f"{sys.version_info.major}.{sys.version_info.minor}"

agentx/evaluations/datasets.py

@@ -57,16 +57,22 @@ class DatasetBuilder:
             main["expectedKnowledgeBase"] = expected_knowledge_base
         if expected_delegations:
             main["expectedDelegations"] = expected_delegations
-        self._payload["questions"].append({
-            "main_question": main,
-            "follow_up_questions": follow_up_questions or [],
-        })
+        self._payload["questions"].append(
+            {
+                "main_question": main,
+                "follow_up_questions": follow_up_questions or [],
+            }
+        )
         return self
 
     def publish(self) -> Dataset:
         if not self._payload["questions"]:
             raise ValueError("Dataset must have at least one case before publishing")
-        logger.info("Publishing dataset '%s' with %d case(s)", self._payload["name"], len(self._payload["questions"]))
+        logger.info(
+            "Publishing dataset '%s' with %d case(s)",
+            self._payload["name"],
+            len(self._payload["questions"]),
+        )
         return self._client.create_dataset(self._payload)
 
     # ------------------------------------------------------------------
@@ -109,9 +115,15 @@ class DatasetBuilder:
                 builder.add_case(
                     query=query,
                     expected_results=row.get("expected_results", "").strip() or None,
-                    expected_capabilities=_split_semi(row.get("expected_capabilities", "")),
-                    expected_knowledge_base=_split_semi(row.get("expected_knowledge_base", "")),
-                    expected_delegations=_split_semi(row.get("expected_delegations", "")),
+                    expected_capabilities=_split_semi(
+                        row.get("expected_capabilities", "")
+                    ),
+                    expected_knowledge_base=_split_semi(
+                        row.get("expected_knowledge_base", "")
+                    ),
+                    expected_delegations=_split_semi(
+                        row.get("expected_delegations", "")
+                    ),
                 )
 
         if invalid:
@@ -150,7 +162,9 @@ class DatasetBuilder:
                 query=query,
                 expected_results=_str_or_none(row.get("expected_results")),
                 expected_capabilities=_split_semi(row.get("expected_capabilities", "")),
-                expected_knowledge_base=_split_semi(row.get("expected_knowledge_base", "")),
+                expected_knowledge_base=_split_semi(
+                    row.get("expected_knowledge_base", "")
+                ),
                 expected_delegations=_split_semi(row.get("expected_delegations", "")),
             )
 
@@ -204,6 +218,7 @@ class DatasetClient:
 # Helpers
 # ---------------------------------------------------------------------------
 
+
 def _split_semi(value: Any) -> Optional[List[str]]:
     if not value:
         return None

agentx/evaluations/models.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
 from typing import Any, Dict, List, Literal, Optional, Union
-from pydantic import BaseModel, Field
-
+from pydantic import BaseModel, Field, model_validator
 
 # ---------------------------------------------------------------------------
 # Observable trace
 # ---------------------------------------------------------------------------
 
+
 class TraceEvent(BaseModel):
     type: str
     name: Optional[str] = None
@@ -30,6 +30,7 @@ class ObservableTrace(BaseModel):
 # Dataset
 # ---------------------------------------------------------------------------
 
+
 class TestCase(BaseModel):
     query: str
     expected_results: Optional[str] = None
@@ -68,8 +69,17 @@ class Dataset(BaseModel):
 # ---------------------------------------------------------------------------
 
 FrameworkKind = Literal[
-    "raw_python", "openai", "anthropic", "google", "langchain", "llamaindex",
-    "crewai", "autogen", "n8n", "flowise", "other"
+    "raw_python",
+    "openai",
+    "anthropic",
+    "google",
+    "langchain",
+    "llamaindex",
+    "crewai",
+    "autogen",
+    "n8n",
+    "flowise",
+    "other",
 ]
 
 RuntimeKind = Literal["local", "ci", "customer_hosted", "low_code"]
@@ -93,10 +103,15 @@ class EvaluationSubject(BaseModel):
 # Run
 # ---------------------------------------------------------------------------
 
+
 class ServerLimits(BaseModel):
     max_batch_size: int = Field(default=10, alias="maxBatchSize")
-    max_trace_bytes_per_result: int = Field(default=20000, alias="maxTraceBytesPerResult")
-    max_metadata_bytes_per_result: int = Field(default=4000, alias="maxMetadataBytesPerResult")
+    max_trace_bytes_per_result: int = Field(
+        default=20000, alias="maxTraceBytesPerResult"
+    )
+    max_metadata_bytes_per_result: int = Field(
+        default=4000, alias="maxMetadataBytesPerResult"
+    )
 
     class Config:
         populate_by_name = True
@@ -119,6 +134,7 @@ class EvaluationRun(BaseModel):
 # Evaluation case (one item from the dataset, passed to the user's callable)
 # ---------------------------------------------------------------------------
 
+
 class EvaluationCase(BaseModel):
     case_id: str
     question_index: int
@@ -137,6 +153,7 @@ class EvaluationCase(BaseModel):
 # Result produced by the user's callable and normalised by the SDK
 # ---------------------------------------------------------------------------
 
+
 class ResultError(BaseModel):
     type: str
     message: str
@@ -162,7 +179,9 @@ class EvaluationResult(BaseModel):
     run_number: int
     input: Dict[str, Any]
     output: Optional[Dict[str, Any]] = None
-    observable_trace: Optional[ObservableTrace] = Field(default=None, alias="observableTrace")
+    observable_trace: Optional[ObservableTrace] = Field(
+        default=None, alias="observableTrace"
+    )
     error: Optional[ResultError] = None
     timings: Optional[ResultTimings] = None
     metadata: Optional[Dict[str, Any]] = None
@@ -177,6 +196,7 @@ class EvaluationResult(BaseModel):
 # Scored result (returned by API after scoring)
 # ---------------------------------------------------------------------------
 
+
 class ScoredResult(BaseModel):
     idempotency_key: str = Field(alias="idempotencyKey")
     rating: Optional[float] = None
@@ -191,6 +211,7 @@ class ScoredResult(BaseModel):
 # Batch append response
 # ---------------------------------------------------------------------------
 
+
 class BatchAppendResponse(BaseModel):
     run_id: str = Field(alias="runId")
     batch_id: str = Field(alias="batchId")
@@ -198,7 +219,9 @@ class BatchAppendResponse(BaseModel):
     duplicates: int = 0
     failed_validation: int = Field(default=0, alias="failedValidation")
     status: str = "in_progress"
-    scored_results: List[ScoredResult] = Field(default_factory=list, alias="scoredResults")
+    scored_results: List[ScoredResult] = Field(
+        default_factory=list, alias="scoredResults"
+    )
 
     class Config:
         populate_by_name = True
@@ -209,11 +232,14 @@ class BatchAppendResponse(BaseModel):
 # Analysis / report
 # ---------------------------------------------------------------------------
 
+
 class ReportStatistics(BaseModel):
     number_of_runs: int = Field(default=0, alias="numberOfRuns")
     average_rating: float = Field(default=0.0, alias="averageRating")
     min_rating: float = Field(default=0.0, alias="minRating")
     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")
 
     class Config:
         populate_by_name = True
@@ -242,7 +268,9 @@ class ReportResponsePatterns(BaseModel):
 
 class ReportReasoningAnalysis(BaseModel):
     cot_quality: Optional[str] = Field(default=None, alias="cotQuality")
-    reasoning_patterns: List[str] = Field(default_factory=list, alias="reasoningPatterns")
+    reasoning_patterns: List[str] = Field(
+        default_factory=list, alias="reasoningPatterns"
+    )
     reasoning_gaps: List[str] = Field(default_factory=list, alias="reasoningGaps")
     rating: Optional[str] = None
 
@@ -278,17 +306,83 @@ class Report(BaseModel):
     statistics: Optional[ReportStatistics] = None
     summary: Optional[str] = None
     consistency_score: Optional[float] = Field(default=None, alias="consistencyScore")
-    instruction_adherence: Optional[ReportInstructionAdherence] = Field(default=None, alias="instructionAdherence")
-    response_patterns: Optional[ReportResponsePatterns] = Field(default=None, alias="responsePatterns")
-    reasoning_analysis: Optional[ReportReasoningAnalysis] = Field(default=None, alias="reasoningAnalysis")
-    tool_usage_analysis: Optional[ReportToolUsageAnalysis] = Field(default=None, alias="toolUsageAnalysis")
+    instruction_adherence: Optional[ReportInstructionAdherence] = Field(
+        default=None, alias="instructionAdherence"
+    )
+    response_patterns: Optional[ReportResponsePatterns] = Field(
+        default=None, alias="responsePatterns"
+    )
+    reasoning_analysis: Optional[ReportReasoningAnalysis] = Field(
+        default=None, alias="reasoningAnalysis"
+    )
+    tool_usage_analysis: Optional[ReportToolUsageAnalysis] = Field(
+        default=None, alias="toolUsageAnalysis"
+    )
     strengths: List[str] = Field(default_factory=list)
     weaknesses: List[str] = Field(default_factory=list)
     overall_rating: Optional[str] = Field(default=None, alias="overallRating")
     recommendations: List[ReportRecommendation] = Field(default_factory=list)
-    low_scoring_cases: List[Dict[str, Any]] = Field(default_factory=list, alias="lowScoringCases")
+    low_scoring_cases: List[Dict[str, Any]] = Field(
+        default_factory=list, alias="lowScoringCases"
+    )
     dashboard_url: Optional[str] = Field(default=None, alias="dashboardUrl")
 
     class Config:
         populate_by_name = True
         extra = "ignore"
+
+    @model_validator(mode="before")
+    @classmethod
+    def _hoist_similarity_into_statistics(cls, data: Any) -> Any:
+        """Backend may send similarity metrics either at the top level (e.g.
+        ``cosineSimilarity``) or nested under ``statistics``. Normalize so the
+        nested form is always populated when either is present."""
+        if not isinstance(data, dict):
+            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"),
+        ):
+            top_val = data.get(top_key)
+            if top_val is None:
+                continue
+            if (
+                stats.get("cosineSimilarity") is None
+                and stats.get("cosine_similarity") is None
+                and "cosine" in nested_key.lower()
+            ):
+                stats[nested_key] = top_val
+            if (
+                stats.get("jaccardSimilarity") is None
+                and stats.get("jaccard_similarity") is None
+                and "jaccard" in nested_key.lower()
+            ):
+                stats[nested_key] = top_val
+        if stats:
+            data["statistics"] = stats
+        return data
+
+    @property
+    def cosine_similarity(self) -> Optional[float]:
+        """Average cosine similarity across scored results, or ``None`` if the
+        metric was not enabled for the dataset or no result has a value yet."""
+        return (
+            self.statistics.cosine_similarity if self.statistics is not None else None
+        )
+
+    @property
+    def jaccard_similarity(self) -> Optional[float]:
+        """Average Jaccard similarity across scored results, or ``None`` if the
+        metric was not enabled for the dataset or no result has a value yet."""
+        return (
+            self.statistics.jaccard_similarity if self.statistics is not None else None
+        )
+
+    @property
+    def average_rating(self) -> Optional[float]:
+        """Convenience accessor matching cosine_similarity / jaccard_similarity."""
+        return self.statistics.average_rating if self.statistics is not None else None

agentx/evaluations/redaction.py

@@ -5,10 +5,10 @@ from typing import Any, Dict
 
 # Patterns that look like secrets
 _SECRET_PATTERNS = [
-    re.compile(r"sk-[A-Za-z0-9]{20,}"),          # OpenAI / Anthropic style keys
+    re.compile(r"sk-[A-Za-z0-9]{20,}"),  # OpenAI / Anthropic style keys
     re.compile(r"Bearer\s+[A-Za-z0-9\-._~+/]+=*", re.IGNORECASE),
     re.compile(r"(?i)(password|passwd|secret|token|api[_-]?key)\s*[=:]\s*\S+"),
-    re.compile(r"[A-Za-z0-9+/]{40,}={0,2}"),      # long base64-like strings
+    re.compile(r"[A-Za-z0-9+/]{40,}={0,2}"),  # long base64-like strings
 ]
 
 _REDACTED = "[REDACTED]"
@@ -33,9 +33,21 @@ def redact_dict(obj: Any, _depth: int = 0) -> Any:
 
 
 _SENSITIVE_KEYS = {
-    "password", "passwd", "secret", "token", "api_key", "apikey",
-    "authorization", "auth", "cookie", "session", "credential",
-    "private_key", "privatekey", "access_key", "accesskey",
+    "password",
+    "passwd",
+    "secret",
+    "token",
+    "api_key",
+    "apikey",
+    "authorization",
+    "auth",
+    "cookie",
+    "session",
+    "credential",
+    "private_key",
+    "privatekey",
+    "access_key",
+    "accesskey",
 }
 
 

agentx/evaluations/reporting.py

@@ -2,15 +2,23 @@ from __future__ import annotations
 
 from agentx.evaluations.models import Report
 from agentx.evaluations._term import (
-    bold, cyan, dim, green, yellow, red, magenta, RESET, BOLD,
+    bold,
+    cyan,
+    dim,
+    green,
+    yellow,
+    red,
+    magenta,
+    RESET,
+    BOLD,
 )
 
-_SEP  = "─" * 60
+_SEP = "─" * 60
 _THIN = "─" * 40
 
 _RATING_COLORS = {"high": green, "medium": yellow, "low": red}
-_RATING_ICONS  = {"high": "●", "medium": "◑", "low": "○"}
-_PRI_COLORS    = {"high": red, "medium": yellow, "low": dim}
+_RATING_ICONS = {"high": "●", "medium": "◑", "low": "○"}
+_PRI_COLORS = {"high": red, "medium": yellow, "low": dim}
 
 
 def _rating_badge(rating: str | None) -> str:
@@ -32,14 +40,32 @@ def print_report(report: Report) -> None:
     print(cyan(_SEP))
     print(f"  {dim('Run     :')} {dim(report.run_id)}")
     print(f"  {dim('Dataset :')} {dim(report.dataset_id)}")
-    print(f"  {dim('Status  :')} {green(report.status) if report.status == 'completed' else yellow(report.status)}")
+    print(
+        f"  {dim('Status  :')} {green(report.status) if report.status == 'completed' else yellow(report.status)}"
+    )
 
     if report.statistics:
         s = report.statistics
         avg = s.average_rating
         avg_color = green if avg >= 7 else (yellow if avg >= 4 else red)
         print(f"  {dim('Cases   :')} {s.number_of_runs}")
-        print(f"  {dim('Rating  :')} {avg_color(f'{avg:.1f}/10')}  {dim(f'(min {s.min_rating:.1f} / max {s.max_rating:.1f})')}")
+        print(
+            f"  {dim('Rating  :')} {avg_color(f'{avg:.1f}/10')}  {dim(f'(min {s.min_rating:.1f} / max {s.max_rating:.1f})')}"
+        )
+
+    cos = report.cosine_similarity
+    if cos is not None:
+        cos_color = green if cos >= 0.85 else (yellow if cos >= 0.6 else red)
+        print(
+            f"  {dim('Cosine  :')} {cos_color(f'{cos * 100:.1f}%')}  {dim('(vector similarity)')}"
+        )
+
+    jac = report.jaccard_similarity
+    if jac is not None:
+        jac_color = green if jac >= 0.6 else (yellow if jac >= 0.3 else red)
+        print(
+            f"  {dim('Jaccard :')} {jac_color(f'{jac * 100:.1f}%')}  {dim('(token-set overlap)')}"
+        )
 
     if report.consistency_score is not None:
         cs = report.consistency_score
@@ -120,8 +146,8 @@ def print_report(report: Report) -> None:
         )
         for rec in sorted_recs:
             pri_fn = _PRI_COLORS.get(rec.priority or "low", dim)
-            pri  = pri_fn(f"[{rec.priority.upper()}]") if rec.priority else ""
-            cat  = dim(f"({rec.category})") if rec.category else ""
+            pri = pri_fn(f"[{rec.priority.upper()}]") if rec.priority else ""
+            cat = dim(f"({rec.category})") if rec.category else ""
             print(f"  {pri} {cat} {rec.recommendation}")
             if rec.reasoning:
                 print(f"       {dim('→')} {dim(rec.reasoning)}")

agentx/evaluations/results.py

@@ -58,9 +58,13 @@ def normalize_result(
         input_tokens = _to_int(raw.get("input_tokens"))
         output_tokens = _to_int(raw.get("output_tokens"))
         if input_tokens is None and isinstance(meta_raw, dict):
-            input_tokens = _to_int(meta_raw.get("input_tokens") or meta_raw.get("prompt_tokens"))
+            input_tokens = _to_int(
+                meta_raw.get("input_tokens") or meta_raw.get("prompt_tokens")
+            )
         if output_tokens is None and isinstance(meta_raw, dict):
-            output_tokens = _to_int(meta_raw.get("output_tokens") or meta_raw.get("completion_tokens"))
+            output_tokens = _to_int(
+                meta_raw.get("output_tokens") or meta_raw.get("completion_tokens")
+            )
 
         err_raw = raw.get("error")
         if err_raw:
@@ -77,7 +81,9 @@ def normalize_result(
     else:
         output = {"text": str(raw)} if raw is not None else {"text": ""}
 
-    has_timings = latency_ms is not None or input_tokens is not None or output_tokens is not None
+    has_timings = (
+        latency_ms is not None or input_tokens is not None or output_tokens is not None
+    )
     return EvaluationResult(
         case_id=case.case_id,
         question_index=case.question_index,
@@ -86,12 +92,22 @@ def normalize_result(
         output=output,
         observableTrace=trace,
         error=error,
-        timings=ResultTimings(latencyMs=latency_ms, inputTokens=input_tokens, outputTokens=output_tokens) if has_timings else None,
+        timings=(
+            ResultTimings(
+                latencyMs=latency_ms,
+                inputTokens=input_tokens,
+                outputTokens=output_tokens,
+            )
+            if has_timings
+            else None
+        ),
         metadata=metadata,
     )
 
 
-def normalize_error(case: EvaluationCase, exc: Exception, latency_ms: Optional[int] = None) -> EvaluationResult:
+def normalize_error(
+    case: EvaluationCase, exc: Exception, latency_ms: Optional[int] = None
+) -> EvaluationResult:
     """Build a failed-case result from an exception."""
     return EvaluationResult(
         case_id=case.case_id,

agentx/evaluations/runner.py

@@ -20,7 +20,15 @@ from agentx.evaluations.redaction import redact_dict
 from agentx.evaluations.reporting import print_report
 from agentx.evaluations.results import normalize_result, normalize_error
 from agentx.evaluations._term import (
-    bold, cyan, green, yellow, red, dim, BOLD, RESET, Spinner,
+    bold,
+    cyan,
+    green,
+    yellow,
+    red,
+    dim,
+    BOLD,
+    RESET,
+    Spinner,
 )
 
 logger = logging.getLogger(__name__)
@@ -80,7 +88,9 @@ class EvaluationRunContext:
         if display:
             print(f"  {dim('Agent :')} {display}  {dim(f'({framework} / {runtime})')}")
         print()
-        print(f"{bold('Executing')}  {n_q} question{'s' if n_q != 1 else ''} × {n_r} run{'s' if n_r != 1 else ''}")
+        print(
+            f"{bold('Executing')}  {n_q} question{'s' if n_q != 1 else ''} × {n_r} run{'s' if n_r != 1 else ''}"
+        )
 
         # Resume: skip already-submitted keys
         already_done = self._fetch_submitted_keys()
@@ -120,7 +130,9 @@ class EvaluationRunContext:
         with Spinner(f"Scoring — AI is rating {n} result{'s' if n != 1 else ''}"):
             try:
                 resp = self._client.append_results(self._run.run_id, batch_id, batch)
-                print(f"  {green('✓')}  Scored {resp.accepted} result{'s' if resp.accepted != 1 else ''}")
+                print(
+                    f"  {green('✓')}  Scored {resp.accepted} result{'s' if resp.accepted != 1 else ''}"
+                )
                 logger.info(
                     "Batch %s: accepted=%d duplicates=%d failed=%d",
                     batch_id[:8],
@@ -229,12 +241,17 @@ class EvaluationsRunner:
 # Helpers
 # ---------------------------------------------------------------------------
 
+
 def _wrap_adapter(adapter: AdapterLike) -> Callable[[EvaluationCase], EvaluationResult]:
-    if isinstance(adapter, (RawCallableAdapter, PrecomputedAdapter, HttpEndpointAdapter)):
+    if isinstance(
+        adapter, (RawCallableAdapter, PrecomputedAdapter, HttpEndpointAdapter)
+    ):
         return adapter.run
     if callable(adapter):
         return RawCallableAdapter(adapter).run
-    raise TypeError(f"adapter must be callable or an Adapter instance, got {type(adapter)}")
+    raise TypeError(
+        f"adapter must be callable or an Adapter instance, got {type(adapter)}"
+    )
 
 
 def _build_cases(dataset: Dataset) -> List[EvaluationCase]:
@@ -243,16 +260,18 @@ def _build_cases(dataset: Dataset) -> List[EvaluationCase]:
     for q_idx, question in enumerate(dataset.questions):
         mq = question.main_question
         for run_num in range(1, n_runs + 1):
-            cases.append(EvaluationCase(
-                case_id=f"case-{q_idx}",
-                question_index=q_idx,
-                run_number=run_num,
-                query=mq.query,
-                expected_results=mq.expected_results,
-                expected_capabilities=mq.expected_capabilities,
-                expected_knowledge_base=mq.expected_knowledge_base,
-                expected_delegations=mq.expected_delegations,
-            ))
+            cases.append(
+                EvaluationCase(
+                    case_id=f"case-{q_idx}",
+                    question_index=q_idx,
+                    run_number=run_num,
+                    query=mq.query,
+                    expected_results=mq.expected_results,
+                    expected_capabilities=mq.expected_capabilities,
+                    expected_knowledge_base=mq.expected_knowledge_base,
+                    expected_delegations=mq.expected_delegations,
+                )
+            )
     return cases
 
 

agentx/resources/workforce.py

@@ -84,7 +84,9 @@ class Workforce(BaseModel):
         self, conversation_id: str, message: str, context: int = -1
     ) -> Iterator[ChatResponse]:
         """Send a message to a team conversation and stream the response."""
-        url = f"{api_base()}/access/teams/conversations/{conversation_id}/jsonmessagesse"
+        url = (
+            f"{api_base()}/access/teams/conversations/{conversation_id}/jsonmessagesse"
+        )
         response = requests.post(
             url, headers=get_headers(), json={"message": message, "context": context}
         )

agentx/version.py

@@ -1 +1 @@
-VERSION = "0.4.9"
+VERSION = "0.4.10"

agentx_python-0.4.10.dist-info/METADATA

@@ -0,0 +1,198 @@
+Metadata-Version: 2.4
+Name: agentx-python
+Version: 0.4.10
+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
+Author-email: contact@agentx.so
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: urllib3>=1.26.11
+Requires-Dist: certifi
+Requires-Dist: requests
+Requires-Dist: pydantic
+Requires-Dist: pydantic_core
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+![Logo](https://agentx-resources.s3.us-west-1.amazonaws.com/AgentX-logo-387x60.png)
+
+[![PyPI version](https://img.shields.io/pypi/v/agentx-python)](https://pypi.org/project/agentx-python/)
+
+The official Python SDK for **[AgentX](https://www.agentx.so/)** — build, chat with, and orchestrate AI agents in a few lines of code.
+
+---
+
+## Contents
+
+- [Why AgentX](#why-agentx)
+- [Installation](#installation)
+- [Authentication](#authentication)
+- [Quick start](#quick-start)
+- [Working with agents](#working-with-agents)
+  - [List agents](#list-agents)
+  - [Start a conversation](#start-a-conversation)
+  - [Chat (streaming and non-streaming)](#chat-streaming-and-non-streaming)
+- [Workforce (multi-agent orchestration)](#workforce-multi-agent-orchestration)
+- [Agent Evaluations](#custom-agent-evaluations) — LLM-as-a-judge, cosine / Jaccard similarity
+- [Links](#links)
+
+---
+
+## Why AgentX
+
+- **Simple mental model** — `Agent → Conversation → Message`.
+- **Chain-of-thought** is built in, no extra plumbing.
+- **Bring any LLM** — works across major open and closed-source vendors.
+- **Batteries included** — voice (ASR/TTS), image generation, document/CSV/Excel/OCR, RAG with built-in re-ranking.
+- **MCP support** — connect any Model Context Protocol server.
+- **Multi-agent orchestration** — workforces of agents with a designated manager, across LLM vendors.
+- **Agent Evaluations** — score any agent (LangChain, CrewAI, OpenAI, Anthropic, HTTP, …) with LLM-as-a-judge ratings plus optional cosine and Jaccard similarity metrics.
+- **A2A** — Each agent can be published with agent-to-agent protocol compatible.
+
+---
+
+## Installation
+
+```bash
+pip install --upgrade agentx-python
+```
+
+Requires Python 3.9 or newer.
+
+---
+
+## Authentication
+
+Get your API key at [app.agentx.so](https://app.agentx.so), then either pass it inline or expose it as an environment variable.
+
+```python
+# Option A — pass the key inline
+from agentx import AgentX
+client = AgentX(api_key="your-api-key-here")
+
+# Option B — set AGENTX_API_KEY in your environment, then:
+client = AgentX.from_env()
+```
+
+---
+
+## Quick start
+
+```python
+from agentx import AgentX
+
+client = AgentX.from_env()
+
+# Pick an existing agent and chat with it
+agent = client.list_agents()[0]
+conversation = agent.new_conversation()
+print(conversation.chat("Hello! What can you help me with?"))
+```
+
+That's it. The remaining sections show the same primitives in more detail.
+
+---
+
+## Working with agents
+
+### List agents
+
+```python
+agents = client.list_agents()
+print(f"You have {len(agents)} agents")
+```
+
+### Start a conversation
+
+```python
+agent = client.get_agent(id="<agent-id>")
+
+# Either resume an existing conversation…
+existing = agent.list_conversations()
+last = existing[-1]
+for msg in last.list_messages():
+    print(msg)
+
+# …or start a fresh one
+conversation = agent.new_conversation()
+```
+
+### Chat (streaming and non-streaming)
+
+```python
+# Blocking — returns the full response once it's ready
+response = conversation.chat("What is your name?")
+print(response)
+
+# Streaming — yields ChatResponse objects as the model produces them
+for chunk in conversation.chat_stream("Hello, what is your name?"):
+    if chunk.text:
+        print(chunk.text, end="")
+```
+
+Each `ChatResponse` chunk exposes the agent's `text` and, where applicable, its `cot` (chain-of-thought) reasoning, along with any retrieved references and tasks.
+
+---
+
+## Workforce (multi-agent orchestration)
+
+A **workforce** is a team of agents coordinated by a designated manager agent. Workforces can mix LLM vendors and route work between specialists.
+
+```python
+workforces = client.list_workforces()
+workforce = workforces[0]
+
+print(f"Workforce: {workforce.name}")
+print(f"Manager:   {workforce.manager.name}")
+print(f"Agents:    {[a.name for a in workforce.agents]}")
+
+# Chat with the workforce — the manager decides which agent(s) to delegate to
+conversation = workforce.new_conversation()
+for chunk in workforce.chat_stream(conversation.id, "How can you help me with this project?"):
+    if chunk.text:
+        print(chunk.text, end="")
+```
+
+---
+
+## 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.
+
+```python
+report = (
+    client.evaluations
+    .run(dataset_id="evds_…", subject={"kind": "custom_agent", "framework": "raw_python"})
+    .execute(my_agent_fn)
+    .finalize()
+    .analyze()
+)
+
+print(report.average_rating)       # LLM-graded score, 0–10
+print(report.cosine_similarity)    # embedding cosine, 0–1 (None if not enabled)
+print(report.jaccard_similarity)   # token-set overlap, 0–1 (None if not enabled)
+```
+
+See **[EVALUATIONS.md](EVALUATIONS.md)** for the full guide — dataset builder, framework adapters, similarity metrics, and the complete API reference.
+
+---
+
+## Links
+
+- **Dashboard** — [app.agentx.so](https://app.agentx.so)
+- **Website** — [agentx.so](https://www.agentx.so/)
+- **PyPI** — [agentx-python](https://pypi.org/project/agentx-python/)
+- **Evaluations docs** — [EVALUATIONS.md](EVALUATIONS.md)

agentx_python-0.4.10.dist-info/RECORD

@@ -0,0 +1,27 @@
+agentx/__init__.py,sha256=AiY83tsCtjSMIBVsvNuxOgSU4i-rCREQrqDrNmCoSd0,279
+agentx/agentx.py,sha256=_I2n77Db0rV3TSDZ44h1Trb6DluDoCBiMsu_KgdNU8I,3012
+agentx/util.py,sha256=yOV3VVdc0KUbw5pEkSRiO2lZzEtL1vOsnB_f5tFk948,665
+agentx/version.py,sha256=QnLb5RDU7syePvc1qNaT3NKjL1mC7ZCUkl8JHLvJm_8,19
+agentx/evaluations/__init__.py,sha256=OmdCHiBO3Qcsck0UkOyVqSvfRs6nXbSi-2FXzyRfsog,89
+agentx/evaluations/_term.py,sha256=S4blZgH66wHvkt2hR29h8JE5xnakBeD7dlZdUW9Wfoo,2065
+agentx/evaluations/client.py,sha256=6y6_o0rZgMKOQLVIZEfgDhD7H_oMDXG3Em5pql7rJlU,7048
+agentx/evaluations/datasets.py,sha256=_VaL6fQ8q33qpiawDr7qORQID8oJwNwMVgdNxM9FOns,8107
+agentx/evaluations/models.py,sha256=G-F_LRK-pT1fYLSqVzHxSCtuRVPpmKALmR1Zr0W-gac,12773
+agentx/evaluations/redaction.py,sha256=arvY9f9XxKHl6-K8P60Xzhb330nXF8a3wOp15d9i0bo,1410
+agentx/evaluations/reporting.py,sha256=JJejSUhgnlYDJXEPgLqR9JoJXAPWDiu3fBGnKHM5EIM,5851
+agentx/evaluations/results.py,sha256=tbUbewEpOyDlcUKxnSRk2m2pCDWk-NuHaAnmI8YZTGQ,4052
+agentx/evaluations/runner.py,sha256=gJY9qSwhNmeKxMBm9AvDNk-WsdR9qU-OuasZbqYxikM,10593
+agentx/evaluations/tracing.py,sha256=MSJD9bzfInMi7E70mc8mWUc0fx5DLkOgUzRru2mNQoc,1825
+agentx/evaluations/adapters/__init__.py,sha256=fK8Hx75usbiY03XUSmnLnSrwBXip2CQs24YZcdEgj6w,287
+agentx/evaluations/adapters/http_endpoint.py,sha256=3YDwpf9u6u3Xj8kLhERmShBeGMviKHCA0Dhr0t6KMmA,2061
+agentx/evaluations/adapters/precomputed.py,sha256=BNNLQuzYFWyLSwsrMGv6MvRTroKY5Hz-Lm4F2RszESU,1210
+agentx/evaluations/adapters/raw.py,sha256=FkDq_mdf21-xt5EHnGyIGcS6VZxkEkFcmM9VTd-T5sA,1130
+agentx/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentx/resources/agent.py,sha256=ZKpxDYzJbKgOX4-W86U__b4gko7XlbwB4q6L8Az9uo0,2011
+agentx/resources/conversation.py,sha256=sDaIhTQPiM3MvAKBK0SKVtBF-LppBXXfRv1-r_aFLoc,4431
+agentx/resources/workforce.py,sha256=lfGVkoV9lcOp-lZScjTvwRarJMkhzfMfLm4syJDujGc,4168
+agentx_python-0.4.10.dist-info/licenses/LICENSE,sha256=6ZbiPNFmv3xBb44LGhAa3PZYK0ROAztsd5LRFZDlGFE,1074
+agentx_python-0.4.10.dist-info/METADATA,sha256=vpaVPSOKSN3GaQ_p-i8rKQtXwgYTYMDdzGbsaiFT6gM,6078
+agentx_python-0.4.10.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+agentx_python-0.4.10.dist-info/top_level.txt,sha256=s-q-HB9Gb_QdrZNacSeQyF_c25gQooMy7DlxzgLOHPk,7
+agentx_python-0.4.10.dist-info/RECORD,,

agentx_python-0.4.9.dist-info/METADATA

@@ -1,141 +0,0 @@
-Metadata-Version: 2.4
-Name: agentx-python
-Version: 0.4.9
-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
-Author-email: contact@agentx.so
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: urllib3>=1.26.11
-Requires-Dist: certifi
-Requires-Dist: requests
-Requires-Dist: pydantic
-Requires-Dist: pydantic_core
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-![Logo](https://agentx-resources.s3.us-west-1.amazonaws.com/AgentX-logo-387x60.png)
-
-[![PyPI version](https://img.shields.io/pypi/v/agentx-python)](https://pypi.org/project/agentx-python/)
-
----
-
-## A fast way to build AI Agents and create agent workforces
-
-The official AgentX Python SDK for [AgentX](https://www.agentx.so/)
-
-Why build AI agents with AgentX?
-
-- Simplicity — Agent → Conversation → Message structure.
-- Chain-of-thought built in.
-- Choose from most open and closed-source LLM vendors.
-- Built-in Voice (ASR, TTS), Image Gen, Document, CSV/Excel, OCR, and more.
-- Support for all running MCP (Model Context Protocol) servers.
-- RAG with built-in re-rank.
-- Multi-agent workforce orchestration.
-- Multiple agents working together with a designated manager agent.
-- Cross-LLM-vendor, multi-agent orchestration.
-- A2A — agent-to-agent protocol (coming soon)
-
-## Installation
-
-```bash
-pip install --upgrade agentx-python
-```
-
-## Quick Start
-
-```python
-from agentx import AgentX
-
-client = AgentX(api_key="your-api-key-here")
-
-agents = client.list_agents()
-print(f"You have {len(agents)} agents")
-
-if agents:
-    agent = agents[0]
-    conversation = agent.new_conversation()
-    response = conversation.chat("Hello! What can you help me with?")
-    print(response)
-```
-
-## Usage
-
-Provide an `api_key` inline or set `AGENTX_API_KEY` as an environment variable.
-Get your API key at https://app.agentx.so
-
-### Agent
-
-```python
-from agentx import AgentX
-
-client = AgentX(api_key="<your api key here>")
-print(client.list_agents())
-```
-
-### Conversation
-
-```python
-my_agent = client.get_agent(id="<agent id here>")
-
-existing_conversations = my_agent.list_conversations()
-last_conversation = existing_conversations[-1]
-msgs = last_conversation.list_messages()
-print(msgs)
-```
-
-### Chat
-
-```python
-a_conversation = my_agent.get_conversation(id="<conversation id here>")
-
-response = a_conversation.chat_stream("Hello, what is your name?")
-for chunk in response:
-    print(chunk)
-```
-
-\*`cot` stands for chain-of-thought
-
-### Workforce
-
-```python
-from agentx import AgentX
-
-client = AgentX(api_key="<your api key here>")
-
-workforces = client.list_workforces()
-workforce = workforces[0]
-print(f"Workforce: {workforce.name}")
-print(f"Manager: {workforce.manager.name}")
-print(f"Agents: {[agent.name for agent in workforce.agents]}")
-```
-
-#### Chat with Workforce
-
-```python
-conversation = workforce.new_conversation()
-response = workforce.chat_stream(conversation.id, "How can you help me with this project?")
-for chunk in response:
-    if chunk.text:
-        print(chunk.text, end="")
-```
-
----
-
-## Custom Agent Evaluations
-
-See **[EVALUATIONS.md](EVALUATIONS.md)** for full documentation — installation, dataset builder, framework examples (OpenAI, Anthropic, Google, LangChain, CrewAI, AutoGen, LlamaIndex, HTTP endpoints), and the complete API reference.

agentx_python-0.4.9.dist-info/RECORD

@@ -1,27 +0,0 @@
-agentx/__init__.py,sha256=AiY83tsCtjSMIBVsvNuxOgSU4i-rCREQrqDrNmCoSd0,279
-agentx/agentx.py,sha256=ICZ5oT-WESgkVBuYExLOAGrYoJUdGoAKYa3BsfD6W_g,3011
-agentx/util.py,sha256=yOV3VVdc0KUbw5pEkSRiO2lZzEtL1vOsnB_f5tFk948,665
-agentx/version.py,sha256=3FouI0PeO06qTMDNHCv_qKuT_7JOUBQr5L9BYxVd794,18
-agentx/evaluations/__init__.py,sha256=OmdCHiBO3Qcsck0UkOyVqSvfRs6nXbSi-2FXzyRfsog,89
-agentx/evaluations/_term.py,sha256=Vcfx89TiORVvh-tGGQfvxtBJEPJsxUv5S7LUplubaAA,2023
-agentx/evaluations/client.py,sha256=Wd44taWQMTjn8SdJohb8K_PIbU0Rzck76G9wpn-RO7k,6858
-agentx/evaluations/datasets.py,sha256=s9B-S7i83JChP9MDjtCMGPMkvz3emXohyQClJD1YVMg,7849
-agentx/evaluations/models.py,sha256=p9yDqJY6YP5FbMZZHS_RsngfCUb7v8LakodrtL3NQ8o,10041
-agentx/evaluations/redaction.py,sha256=zljolnX64kaBUiqrPGD_kSFZvb65z2CvMrryoJtwY3k,1374
-agentx/evaluations/reporting.py,sha256=g1zLJ_BR0IfO3VHEM0xm8wyEkgkQvLJQ-NdIW8lNMD0,5266
-agentx/evaluations/results.py,sha256=-K122Z1_fIaDAeP0neLI9EXwEnPESbu8z5qo_aXRrZY,3859
-agentx/evaluations/runner.py,sha256=5_QIpU8PSAQniFdubW1CnJK4CQ3HQhyN1u683t926hA,10406
-agentx/evaluations/tracing.py,sha256=MSJD9bzfInMi7E70mc8mWUc0fx5DLkOgUzRru2mNQoc,1825
-agentx/evaluations/adapters/__init__.py,sha256=fK8Hx75usbiY03XUSmnLnSrwBXip2CQs24YZcdEgj6w,287
-agentx/evaluations/adapters/http_endpoint.py,sha256=3YDwpf9u6u3Xj8kLhERmShBeGMviKHCA0Dhr0t6KMmA,2061
-agentx/evaluations/adapters/precomputed.py,sha256=yuJrDv6SH1mRSCz3EgxPSUu9iBJeTY2uJflK5S0QxcM,1188
-agentx/evaluations/adapters/raw.py,sha256=AqSHTM3p45LK4Wo1lkUboclMY97SYFx9kzDQ6GNbGA8,1115
-agentx/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-agentx/resources/agent.py,sha256=ZKpxDYzJbKgOX4-W86U__b4gko7XlbwB4q6L8Az9uo0,2011
-agentx/resources/conversation.py,sha256=sDaIhTQPiM3MvAKBK0SKVtBF-LppBXXfRv1-r_aFLoc,4431
-agentx/resources/workforce.py,sha256=QpyQNBQR24MbcAPtrPZZsdfSuXDSOyNmlcfWeHudXmY,4144
-agentx_python-0.4.9.dist-info/licenses/LICENSE,sha256=6ZbiPNFmv3xBb44LGhAa3PZYK0ROAztsd5LRFZDlGFE,1074
-agentx_python-0.4.9.dist-info/METADATA,sha256=-o556esk8h8G-_rhhOxXTUbfUaV4Z_-xK3i1mzK9DYo,3691
-agentx_python-0.4.9.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-agentx_python-0.4.9.dist-info/top_level.txt,sha256=s-q-HB9Gb_QdrZNacSeQyF_c25gQooMy7DlxzgLOHPk,7
-agentx_python-0.4.9.dist-info/RECORD,,