agentx-python 0.8.4__tar.gz → 0.8.6__tar.gz

{agentx_python-0.8.4/agentx_python.egg-info → agentx_python-0.8.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentx-python
-Version: 0.8.4
+Version: 0.8.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

{agentx_python-0.8.4 → agentx_python-0.8.6}/agentx/evaluations/client.py

@@ -60,6 +60,13 @@ class AgentXValidationError(AgentXEvaluationsError):
     pass
 
 
+class EvaluationSubmissionError(AgentXEvaluationsError):
+    """A result batch could not be submitted (after one retry). The run is left unfinalized;
+    re-running execute() on the same context resumes past already-submitted cases."""
+
+    pass
+
+
 def _resolve_scorer_id(scorer_id: Optional[str], evaluation_settings_id: Optional[str]) -> Optional[str]:
     """One grader, two spellings: ``scorer_id`` is the post-consolidation name for what the wire
     still calls ``evaluationSettingsId`` (the ids are identical by design). Both kwargs are
@@ -220,6 +227,12 @@ class EvaluationsClient:
         data = self._request("POST", "/datasets", json=self._with_workspace(payload))
         return Dataset(**data)
 
+    def delete_dataset(self, dataset_id: str) -> None:
+        """Deletes the dataset, its grading config, and both version histories. Past runs are
+        kept (their dataset reference degrades to a bare id). The engine refuses (409) when the
+        dataset's config is attached to a live scorer."""
+        self._request("DELETE", f"/datasets/{dataset_id}")
+
     def list_datasets(self) -> List[Dataset]:
         data = self._request("GET", "/datasets", params=self._workspace_params())
         return [
@@ -297,10 +310,11 @@ class EvaluationsClient:
         python_version: Optional[str] = None,
         scorer_id: Optional[str] = None,
         evaluation_settings_id: Optional[str] = None,
+        split: Optional[str] = None,
     ) -> EvaluationRun:
         """``scorer_id`` names the LLM Judge Scorer grading this run (its id doubles as the
         wire's ``evaluationSettingsId``). ``evaluation_settings_id`` is the pre-consolidation
-        alias and keeps working."""
+        alias and keeps working. ``split`` records the named case subset this run covers."""
         from agentx.version import VERSION
 
         grader_id = _resolve_scorer_id(scorer_id, evaluation_settings_id)
@@ -318,6 +332,8 @@ class EvaluationsClient:
         }
         if grader_id:
             payload["evaluationSettingsId"] = grader_id
+        if split:
+            payload["split"] = split
         data = self._request("POST", "/runs", json=self._with_workspace(payload))
         return EvaluationRun(**data)
 
@@ -436,6 +452,13 @@ class EvaluationsClient:
         data = self._request("GET", f"/runs/{run_id}/missing-results")
         return data if isinstance(data, list) else data.get("missing", [])
 
+    def get_submitted_keys(self, run_id: str) -> List[str]:
+        """Idempotency keys this run has already accepted - what execute() uses to resume a
+        crashed or interrupted run without re-running (and re-paying for) finished cases."""
+        data = self._request("GET", f"/runs/{run_id}/missing-results")
+        keys = data.get("submittedKeys", []) if isinstance(data, dict) else []
+        return [k for k in keys if isinstance(k, str)]
+
     # ------------------------------------------------------------------
     # Self-host analysis fallback
     #

{agentx_python-0.8.4 → agentx_python-0.8.6}/agentx/evaluations/datasets.py

@@ -105,9 +105,15 @@ class DatasetBuilder:
         expected_tools: Optional[List[str]] = None,
         trajectory_match_mode: str = "strict",
         expected_retrieval_context: Optional[Union[str, List[str]]] = None,
+        splits: Optional[List[str]] = None,
     ) -> "DatasetBuilder":
         """Add a case. `judge_guideline` is optional grading guidance specific to this question.
 
+        `splits` tags this case with named subsets (e.g. ``["smoke"]``): a run started with
+        ``client.evaluations.run(dataset_id, subject, split="smoke")`` executes only the tagged
+        cases (original case indexes are preserved, so per-case comparisons still line up with
+        full runs). An untagged case belongs to no split and only runs in full runs.
+
         `expected_tools` declares the tool calls a correct run of this case should make. When a
         result links its trace (return `{"output": ..., "trace_id": span.trace_id}` from the
         agent function), the engine matches the trace's actual tool-call sequence against it and
@@ -149,6 +155,8 @@ class DatasetBuilder:
             main["expectedTrajectory"] = {"tools": expected_tools, "mode": trajectory_match_mode}
         if expected_retrieval_context:
             main["expectedRetrievalContext"] = expected_retrieval_context
+        if splits:
+            main["splits"] = splits
         self._payload["questions"].append(
             {
                 "main_question": main,
@@ -325,6 +333,37 @@ class DatasetClient:
     def list(self) -> List[Dataset]:
         return self._client.list_datasets()
 
+    def delete(self, dataset_id: str) -> None:
+        """Delete a dataset (and its grading config + version histories; past runs are kept)."""
+        self._client.delete_dataset(dataset_id)
+
+    def import_dataset(self, source: Any, name: Optional[str] = None) -> Dataset:
+        """Create a NEW dataset from an exported/fetched one (a ``Dataset`` from ``get()``, or
+        the engine's wire/NDJSON-export dict). Always a copy with a fresh id - never a
+        restore-in-place. ``name`` optionally renames the copy."""
+        wire: Dict[str, Any] = (
+            source.model_dump(by_alias=True) if hasattr(source, "model_dump") else dict(source)
+        )
+        payload: Dict[str, Any] = {
+            "name": name or wire.get("name") or "Imported dataset",
+            "questions": wire.get("questions") or [],
+        }
+        for key in (
+            "description",
+            "numberOfRequests",
+            "acceptanceCriteria",
+            "rejectionCriteria",
+            "evaluationCriteria",
+            "vectorSimilarity",
+            "jaccardSimilarity",
+            "bleuScore",
+            "rougeScore",
+            "codeScorers",
+        ):
+            if wire.get(key) is not None:
+                payload[key] = wire[key]
+        return self._client.create_dataset(payload)
+
 
 # ---------------------------------------------------------------------------
 # Helpers

{agentx_python-0.8.4 → agentx_python-0.8.6}/agentx/evaluations/models.py

@@ -52,6 +52,9 @@ class TestCase(BaseModel):
     expected_delegations: Optional[List[str]] = Field(default=None, alias="expectedDelegations")
     judge_guideline: Optional[str] = Field(default=None, alias="judgeGuideline")
     smoke_test: Optional[SmokeTestSettings] = Field(default=None, alias="smokeTest")
+    # Named subsets this case belongs to (e.g. ["smoke"], ["full", "regression"]).
+    # ``run(dataset_id, split="smoke")`` runs only cases tagged with that split.
+    splits: Optional[List[str]] = None
 
     class Config:
         populate_by_name = True
@@ -412,6 +415,11 @@ class RunResultRow(BaseModel):
 
     rating: Optional[float] = None
     justification: Optional[str] = None
+    # scored | skipped (the judge could not score this row) | failed (the submitted result
+    # carried an error). A skipped row has rating None - a fact about the judge, not a 0.
+    status: Optional[str] = None
+    question_index: Optional[int] = Field(default=None, alias="questionIndex")
+    run_number: Optional[int] = Field(default=None, alias="runNumber")
     question_text: Optional[str] = Field(default=None, alias="questionText")
     response: Optional[str] = None
     trace_id: Optional[str] = Field(default=None, alias="traceId")

{agentx_python-0.8.4 → agentx_python-0.8.6}/agentx/evaluations/runner.py

@@ -4,12 +4,12 @@ import logging
 import os
 import time
 import uuid
-from typing import Any, Callable, Dict, List, Optional, Set, Union
+from typing import Any, Callable, Dict, Iterator, List, Optional, Set, Union
 
 from agentx.evaluations.adapters.raw import RawCallableAdapter
 from agentx.evaluations.adapters.precomputed import PrecomputedAdapter
 from agentx.evaluations.adapters.http_endpoint import HttpEndpointAdapter
-from agentx.evaluations.client import EvaluationsClient
+from agentx.evaluations.client import EvaluationsClient, EvaluationSubmissionError
 from agentx.evaluations.models import (
     AnalysisStatus,
     Dataset,
@@ -96,11 +96,14 @@ class EvaluationRunContext:
         run: EvaluationRun,
         subject: EvaluationSubject,
         evaluation_settings: Optional[EvaluationSettings] = None,
+        split: Optional[str] = None,
     ):
         self._client = client
         self._dataset = dataset
         self._run = run
         self._subject = subject
+        # Named case subset for this run - only cases tagged with it are built/executed.
+        self._split = split
         # When set, this run was started with an independently chosen grading
         # config (evaluation_settings_id) - its fields take precedence over the
         # dataset's own for anything execution-time reads (see _build_cases).
@@ -118,25 +121,63 @@ class EvaluationRunContext:
     # Step 1: execute
     # ------------------------------------------------------------------
 
-    def execute(self, adapter: AdapterLike) -> "EvaluationRunContext":
+    def execute(
+        self,
+        adapter: AdapterLike,
+        concurrency: int = 1,
+        reuse_outputs_from: Optional[str] = None,
+    ) -> "EvaluationRunContext":
         """Run all cases locally and submit batches to AgentX.
 
         The whole loop runs inside the eval-run scope (tracing/eval_scope.py): any trace the
         agent function creates is stamped source="eval-run" + monitor=False automatically, so
         eval traffic never skews production monitoring and no one has to remember a flag.
+
+        ``concurrency`` > 1 runs the agent callable across a thread pool (results are still
+        submitted in case order, and the eval-run scope is propagated into the workers).
+        ``reuse_outputs_from`` replays a previous run's recorded outputs for cases whose query
+        text is unchanged instead of re-running (and re-paying for) the agent - the judge still
+        re-scores them, which makes iterating on scorers cheap. Changed or new cases run
+        normally.
         """
         from agentx.tracing.eval_scope import enter_eval_run, exit_eval_run
 
         scope_token = enter_eval_run(self._run.run_id)
         try:
-            return self._execute_inner(adapter)
+            return self._execute_inner(adapter, concurrency=concurrency, reuse_outputs_from=reuse_outputs_from)
         finally:
             exit_eval_run(scope_token)
 
-    def _execute_inner(self, adapter: AdapterLike) -> "EvaluationRunContext":
+    def _fetch_reusable_outputs(self, run_id: str) -> Dict[tuple, str]:
+        """(query, run_number, is_smoke_variant) -> output text, from a previous run's rows.
+        Keyed on the query TEXT so a reworded case never silently reuses a stale answer."""
+        try:
+            prior = self._client.get_run(run_id)
+        except Exception as exc:
+            logger.warning("reuse_outputs_from: could not load run %s (%s) - running everything", run_id, exc)
+            return {}
+        reusable: Dict[tuple, str] = {}
+        for row in prior.get("results", []) or []:
+            if row.get("error") or row.get("status") == "failed":
+                continue
+            output = (row.get("output") or {}).get("text")
+            query = (row.get("input") or {}).get("query")
+            if not output or not query:
+                continue
+            key = (query, row.get("runNumber") or 1, bool(row.get("isSmokeTestVariant")))
+            reusable[key] = output
+        return reusable
+
+    def _execute_inner(
+        self,
+        adapter: AdapterLike,
+        concurrency: int = 1,
+        reuse_outputs_from: Optional[str] = None,
+    ) -> "EvaluationRunContext":
         normalized = _wrap_adapter(adapter)
-        cases = _build_cases(self._dataset, self._run, self._evaluation_settings)
+        cases = _build_cases(self._dataset, self._run, self._evaluation_settings, split=self._split)
         max_batch = self._run.limits.max_batch_size
+        reusable = self._fetch_reusable_outputs(reuse_outputs_from) if reuse_outputs_from else {}
 
         # Banner
         sep = "─" * 60
@@ -144,7 +185,7 @@ class EvaluationRunContext:
         framework = self._subject.framework or "custom"
         runtime = self._subject.runtime or "local"
         display = self._subject.display_name or ""
-        n_q = len(self._dataset.questions)
+        n_q = len({c.question_index for c in cases if not c.is_smoke_test_variant})
         n_r = (
             self._evaluation_settings.number_of_requests
             if self._evaluation_settings
@@ -171,6 +212,45 @@ class EvaluationRunContext:
         batch: List[EvaluationResult] = []
         total = len(cases)
 
+        def produce(case: EvaluationCase) -> EvaluationResult:
+            # Cached replay: same query text at the same repetition reuses the recorded output
+            # (the server still re-scores it with THIS run's grading config).
+            cached = reusable.get((case.query, case.run_number, case.is_smoke_test_variant))
+            if cached is not None:
+                return normalize_result(
+                    case, {"output": cached, "metadata": {"reusedFromRun": reuse_outputs_from}}
+                )
+            return normalized(case)
+
+        if concurrency > 1:
+            import concurrent.futures
+            import contextvars
+
+            def in_scope(case: EvaluationCase) -> EvaluationResult:
+                # ContextVars (the eval-run scope) do not cross thread boundaries on their own -
+                # each worker task runs inside a copy of the submitting thread's context so the
+                # agent's traces still get stamped source="eval-run".
+                return contextvars.copy_context().run(produce, case)
+
+            pending = [
+                case
+                for case in cases
+                if _idem_key(self._run.run_id, case.case_id, case.run_number) not in already_done
+            ]
+            executor = concurrent.futures.ThreadPoolExecutor(max_workers=concurrency)
+            # map() yields in submission order, so batching/submission below stays deterministic.
+            mapped = executor.map(in_scope, pending)
+
+            def ordered() -> "Iterator[EvaluationResult]":
+                try:
+                    yield from mapped
+                finally:
+                    executor.shutdown(wait=True)
+
+            results_iter = ordered()
+        else:
+            results_iter = None  # sequential path below produces inline
+
         for idx, case in enumerate(cases, start=1):
             idem_key = _idem_key(self._run.run_id, case.case_id, case.run_number)
 
@@ -179,7 +259,7 @@ class EvaluationRunContext:
                 _print_progress(idx, total, case, skipped=True)
                 continue
 
-            result = normalized(case)
+            result = next(results_iter) if results_iter is not None else produce(case)
             result.idempotency_key = idem_key
             # Tag the result with the case's model so the server can group it into
             # the Sovereignty & Portability matrix (the callable may also set it).
@@ -207,31 +287,46 @@ class EvaluationRunContext:
         batch_id = str(uuid.uuid4())
         n = len(batch)
         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)
-                if resp.live_statistics is not None:
-                    self._live_stats = resp.live_statistics
-                _say(
-                    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],
-                    resp.accepted,
-                    resp.duplicates,
-                    resp.failed_validation,
-                )
-            except Exception as exc:
-                _say(f"  {red('✗')}  Scoring failed: {dim(str(exc))}")
-                logger.error("Failed to submit batch %s: %s", batch_id[:8], exc)
+            last_exc: Optional[Exception] = None
+            for attempt in (1, 2):
+                try:
+                    resp = self._client.append_results(self._run.run_id, batch_id, batch)
+                    if resp.live_statistics is not None:
+                        self._live_stats = resp.live_statistics
+                    _say(
+                        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],
+                        resp.accepted,
+                        resp.duplicates,
+                        resp.failed_validation,
+                    )
+                    return
+                except Exception as exc:
+                    last_exc = exc
+                    if attempt == 1:
+                        logger.warning("Batch %s submission failed, retrying once: %s", batch_id[:8], exc)
+        # A batch that cannot be submitted must FAIL the run, not print a red line and carry on:
+        # execute() used to finish "successfully" having uploaded nothing. Failing fast also
+        # stops paying for agent calls whose results would hit the same broken engine; a
+        # re-execute() of this context resumes past everything already accepted (idempotency
+        # keys are deterministic and the engine returns the submitted set).
+        _say(f"  {red('✗')}  Scoring failed: {dim(str(last_exc))}")
+        logger.error("Failed to submit batch %s after retry: %s", batch_id[:8], last_exc)
+        raise EvaluationSubmissionError(
+            f"Failed to submit a batch of {n} result(s) to the engine after a retry: {last_exc}. "
+            "The run was left unfinalized; re-running execute() resumes past already-submitted cases."
+        ) from last_exc
 
     def _fetch_submitted_keys(self) -> Set[str]:
+        """Keys already accepted by this run - the engine's /missing-results route returns them
+        so a re-execute() after a crash skips (and never re-pays for) finished cases."""
         try:
-            missing = self._client.get_missing_results(self._run.run_id)
-            # missing-results returns cases NOT yet submitted - we want the inverse
-            # but if the endpoint isn't live yet, just return empty set
-            return set()
+            return set(self._client.get_submitted_keys(self._run.run_id))
         except Exception:
+            # Older engines without the route: no resume, identical to the historical behavior.
             return set()
 
     # ------------------------------------------------------------------
@@ -517,11 +612,16 @@ class EvaluationsRunner:
         subject: Union[Dict[str, Any], EvaluationSubject],
         scorer_id: Optional[str] = None,
         evaluation_settings_id: Optional[str] = None,
+        split: Optional[str] = None,
     ) -> EvaluationRunContext:
         """Start a run of ``dataset_id`` against ``subject``. Pass ``scorer_id`` (an LLM Judge
         Scorer's id, e.g. from ``client.monitor.judge_scorers``) to grade with a specific
         scorer instead of the dataset's default. ``evaluation_settings_id`` is the
-        pre-consolidation alias for the same id and keeps working."""
+        pre-consolidation alias for the same id and keeps working.
+
+        ``split`` runs only the cases tagged with that named subset (``add_case(...,
+        splits=["smoke"])``) - the cheap-PR-run vs nightly-full-run workflow. Original case
+        indexes are preserved so per-case comparisons line up with full runs."""
         from agentx.evaluations.client import _resolve_scorer_id
 
         if isinstance(subject, dict):
@@ -532,18 +632,24 @@ class EvaluationsRunner:
         evaluation_settings = (
             self._client.get_evaluation_settings(grader_id) if grader_id else None
         )
-        run = self._client.init_run(dataset_id, subject, scorer_id=grader_id)
+        run = self._client.init_run(dataset_id, subject, scorer_id=grader_id, split=split)
+        case_count = (
+            sum(1 for q in dataset.questions if split in (q.main_question.splits or []))
+            if split
+            else len(dataset.questions)
+        )
         logger.info(
-            "Started evaluation run %s on dataset %s (%d case(s), %d repetition(s))",
+            "Started evaluation run %s on dataset %s (%d case(s)%s, %d repetition(s))",
             run.run_id,
             dataset_id,
-            len(dataset.questions),
+            case_count,
+            f' in split "{split}"' if split else "",
             evaluation_settings.number_of_requests
             if evaluation_settings
             else dataset.number_of_requests,
         )
         return EvaluationRunContext(
-            self._client, dataset, run, subject, evaluation_settings=evaluation_settings
+            self._client, dataset, run, subject, evaluation_settings=evaluation_settings, split=split
         )
 
 
@@ -568,6 +674,7 @@ def _build_cases(
     dataset: Dataset,
     run: EvaluationRun,
     evaluation_settings: Optional[EvaluationSettings] = None,
+    split: Optional[str] = None,
 ) -> List[EvaluationCase]:
     cases: List[EvaluationCase] = []
     # When an independent evaluation_settings was chosen (evaluation_settings_id
@@ -596,6 +703,10 @@ def _build_cases(
     }
     for q_idx, question in enumerate(dataset.questions):
         mq = question.main_question
+        # Split filtering preserves q_idx: a "smoke" run's case 7 is the same case 7 a full run
+        # scores, so per-case comparisons line up across the two.
+        if split and split not in (mq.splits or []):
+            continue
         for run_num in range(1, n_runs + 1):
             for model in models:
                 suffix = f"::{model}" if model else ""

{agentx_python-0.8.4 → agentx_python-0.8.6}/agentx/monitor/client.py

@@ -39,6 +39,35 @@ class AgentXValidationError(AgentXMonitorError):
     pass
 
 
+class CalibrationSummary(dict):
+    """Judge Calibration numbers (dict subclass, so existing key access keeps working).
+    Properties mirror the wire's exact camelCase keys."""
+
+    @property
+    def compared_count(self) -> int:
+        return int(self.get("comparedCount") or 0)
+
+    @property
+    def agreement_rate(self):
+        return self.get("agreementRate")
+
+    @property
+    def false_positive_rate(self):
+        return self.get("falsePositiveRate")
+
+    @property
+    def false_negative_rate(self):
+        return self.get("falseNegativeRate")
+
+    @property
+    def reported_count(self) -> int:
+        return int(self.get("reportedCount") or 0)
+
+    @property
+    def review_label_count(self) -> int:
+        return int(self.get("reviewLabelCount") or 0)
+
+
 class MonitorClient:
     """Low-level HTTP client for the Monitor API (``/monitor``). Accessed via
     ``client.monitor`` on the top-level :class:`agentx.AgentX` instance; most callers
@@ -82,6 +111,11 @@ class MonitorClient:
 
         self.patterns = MonitorPatternClient(self)
         self.signals = MonitorSignalClient(self)
+        from agentx.monitor.review_queue import ReviewQueueClient
+
+        # The human-review queue (list / queue / label / dismiss) - what makes the
+        # label-and-calibrate loop scriptable instead of dashboard-only.
+        self.review_queue = ReviewQueueClient(self)
         from agentx.monitor.scorers import ScorersClient
         # Scorers-catalog administration as code: template enable/disable, code/external scorer
         # CRUD and dry runs - full parity with the dashboard's Scorers page (P1.3).
@@ -230,15 +264,19 @@ class MonitorClient:
         plus deltas vs the prior window and the run-outcome breakdown."""
         return self._request("GET", "/kpis", params={"window": window})
 
-    def calibration(self, window: str = "7d") -> dict:
+    def calibration(self, window: str = "7d") -> "CalibrationSummary":
         """Project-level judge calibration over a window ("24h", "7d", or "30d"): how often
         AgentX's own verdicts agreed with real-world ground truth reported later (ops outcomes
-        via ``client.outcomes`` and end-user downvotes). Returns the dashboard's Judge
-        Calibration numbers: compared count, agreement, falsePositiveRate, falseNegativeRate.
-        Per-evaluator calibration lives on ``client.monitor.online_evaluators.calibration``."""
-        return self._request(
-            "GET", "/agent-monitoring/calibration",
-            base=self._api_root(), params={"window": window},
+        via ``client.outcomes``, end-user downvotes, and human review labels). Returns the
+        dashboard's Judge Calibration numbers with these exact keys: ``comparedCount``,
+        ``agreementRate``, ``falsePositiveRate``, ``falseNegativeRate`` (plus
+        ``reportedCount``/``reviewLabelCount``/``noVerdictCount``). Per-scorer calibration
+        lives on ``client.monitor.judge_scorers.calibration(scorer_id)``."""
+        return CalibrationSummary(
+            self._request(
+                "GET", "/agent-monitoring/calibration",
+                base=self._api_root(), params={"window": window},
+            )
         )
 
     # ------------------------------------------------------------------
@@ -352,10 +390,19 @@ class MonitorClient:
             base=self._api_root(), json={**criteria, "window": window}, timeout=600,
         )
 
-    def publish_online_evaluator_tuning(self, evaluator_id: str, criteria: dict) -> dict:
+    def publish_online_evaluator_tuning(
+        self, evaluator_id: str, criteria: dict, *, validation: Optional[dict] = None, force: bool = False
+    ) -> dict:
+        # The engine gates publish on validation provenance (and refuses a measured regression)
+        # unless forced - see judge_scorers.publish_tuning for the full story.
+        payload = dict(criteria)
+        if validation is not None:
+            payload["validation"] = validation
+        if force:
+            payload["force"] = True
         return self._request(
             "POST", f"/agent-monitoring/online-evaluators/{evaluator_id}/tune/publish",
-            base=self._api_root(), json=criteria, timeout=60,
+            base=self._api_root(), json=payload, timeout=60,
         )
 
     def update_profile(self, agent_id: str, payload: dict) -> MonitorProfile:

{agentx_python-0.8.4 → agentx_python-0.8.6}/agentx/monitor/judge_scorers.py

@@ -280,12 +280,30 @@ class JudgeScorersClient:
             timeout=600,
         )
 
-    def publish_tuning(self, scorer_id: str, criteria: Dict[str, Any]) -> dict:
+    def publish_tuning(
+        self,
+        scorer_id: str,
+        criteria: Dict[str, Any],
+        *,
+        validation: Optional[Dict[str, Any]] = None,
+        force: bool = False,
+    ) -> dict:
         """Write tuned criteria onto the scorer's rubric - it applies everywhere the scorer is
-        used: online scoring, offline dataset runs, and the playground."""
-        return self._request(
-            "POST", f"/online-evaluators/{self._profile_id(scorer_id)}/tune/publish", json=dict(criteria)
-        )
+        used: online scoring, offline dataset runs, and the playground.
+
+        The engine gates publish on provenance: pass ``validation`` (the dict returned by
+        ``validate_tuning``, or at least its ``verdict``/``netAgreementGain``) so the version
+        history records what the change measurably did; a ``regressed`` verdict is refused.
+        ``force=True`` publishes without (or despite) validation - deliberate escape hatch."""
+        payload = dict(criteria)
+        if validation is not None:
+            payload["validation"] = {
+                "verdict": validation.get("verdict"),
+                "netAgreementGain": validation.get("netAgreementGain"),
+            }
+        if force:
+            payload["force"] = True
+        return self._request("POST", f"/online-evaluators/{self._profile_id(scorer_id)}/tune/publish", json=payload)
 
     def ratings(self, scorer_id: str, window: str = "7d") -> "List[OnlineEvaluatorRatingPoint]":
         """Bucketed average-rating-over-time for this scorer's live checks - same typed points

{agentx_python-0.8.4 → agentx_python-0.8.6}/agentx/monitor/online_evaluators.py

@@ -157,9 +157,13 @@ class MonitorOnlineEvaluatorClient:
         is {acceptanceCriteria, rejectionCriteria, evaluationCriteria} from tune()."""
         return self._client.validate_online_evaluator_tuning(evaluator_id, criteria, window)
 
-    def publish_tuning(self, evaluator_id: str, criteria: dict) -> dict:
-        """Publish tuned criteria onto the evaluator's config (the human-approval step)."""
-        return self._client.publish_online_evaluator_tuning(evaluator_id, criteria)
+    def publish_tuning(
+        self, evaluator_id: str, criteria: dict, *, validation: Optional[dict] = None, force: bool = False
+    ) -> dict:
+        """Publish tuned criteria onto the evaluator's config (the human-approval step).
+        Pass ``validation`` (the ``validate_tuning`` result) - the engine refuses an unvalidated
+        publish, and a ``regressed`` verdict, unless ``force=True``."""
+        return self._client.publish_online_evaluator_tuning(evaluator_id, criteria, validation=validation, force=force)
 
     def ratings(self, evaluator_id: str, window: str = "7d") -> List[OnlineEvaluatorRatingPoint]:
         """Bucketed average-rating-over-time for this evaluator. ``window`` is one of