traigent 0.21.0.dev2__tar.gz → 0.21.1.dev0__tar.gz

{traigent-0.21.0.dev2/traigent.egg-info → traigent-0.21.1.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: traigent
-Version: 0.21.0.dev2
+Version: 0.21.1.dev0
 Summary: Enterprise-grade LLM optimization platform with advanced analytics and AI-powered insights
 Author-email: Traigent Team <opensource@traigent.ai>
 License-Expression: AGPL-3.0-only OR LicenseRef-Traigent-Commercial

{traigent-0.21.0.dev2 → traigent-0.21.1.dev0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "traigent"
-version = "0.21.0.dev2"
+version = "0.21.1.dev0"
 authors = [
     {name = "Traigent Team", email = "opensource@traigent.ai"},
 ]

{traigent-0.21.0.dev2 → traigent-0.21.1.dev0}/traigent/cloud/api_operations.py

@@ -30,6 +30,8 @@ from traigent.cloud.models import (
     SessionCreationResponse,
     TrialResultSubmission,
 )
+from traigent.cloud.session_budgets import remember_cost_budget_armed_session
+from traigent.cloud.session_objectives import normalize_typed_objectives
 from traigent.cloud.smart_pruning import (
     normalize_intermediate_report_payload,
     normalize_smart_pruning_options,
@@ -523,9 +525,13 @@ class ApiOperations:
                 {"Content-Type": _JSON_CONTENT_TYPE}
             )
             try:
-                return await self._post_session_creation(
+                result = await self._post_session_creation(
                     session_payload, headers, connector
                 )
+                remember_cost_budget_armed_session(
+                    self.client, result[0], session_payload.get("budget")
+                )
+                return result
             except CloudServiceError as typed_exc:
                 # auto-contract fallback: a failed TYPED create may retry the
                 # legacy shape ONCE — and only for NON-governed sessions
@@ -675,6 +681,12 @@ class ApiOperations:
         strategy = getattr(session_request, "optimization_strategy", None)
         return dict(strategy) if isinstance(strategy, dict) and strategy else None
 
+    @staticmethod
+    def _normalize_typed_objectives(objectives: Any) -> list[Any]:
+        """Compatibility wrapper around the shared typed objective normalizer."""
+
+        return normalize_typed_objectives(objectives)
+
     def _build_typed_session_payload(
         self, session_request: SessionCreationRequest, max_trials: int
     ) -> dict[str, Any]:
@@ -695,7 +707,7 @@ class ApiOperations:
             "configuration_space": _typed_configuration_space(
                 session_request.configuration_space
             ),
-            "objectives": list(session_request.objectives or []),
+            "objectives": self._normalize_typed_objectives(session_request.objectives),
             "dataset_metadata": dataset_metadata,
             "max_trials": max_trials,
             "metadata": {

{traigent-0.21.0.dev2 → traigent-0.21.1.dev0}/traigent/cloud/backend_client.py

@@ -58,6 +58,10 @@ from traigent.cloud.models import (
     TrialResultSubmission,
     TrialSuggestion,
 )
+from traigent.cloud.session_budgets import (
+    is_cost_budget_armed_session,
+    remember_cost_budget_armed_session,
+)
 
 # Import refactored sub-modules
 from traigent.cloud.privacy_operations import PrivacyOperations
@@ -765,6 +769,7 @@ class BackendIntegratedClient:
         self._session = None
         self._active_sessions: dict[str, OptimizationSession] = {}
         self._active_sessions_lock = Lock()
+        self._cost_budget_armed_sessions: set[str] = set()
 
         # Memory bounds to prevent unbounded growth
         self._max_active_sessions = 100  # Maximum concurrent sessions
@@ -826,6 +831,18 @@ class BackendIntegratedClient:
         logger.info("using local interaction policy")
         self._interaction_policy_fallback_logged = True
 
+    def _remember_cost_budget_armed_session(
+        self, session_id: str, budget: Mapping[str, Any] | None
+    ) -> None:
+        """Track sessions whose typed create armed a positive cost budget."""
+
+        remember_cost_budget_armed_session(self, session_id, budget)
+
+    def _is_cost_budget_armed_session(self, session_id: str) -> bool:
+        """Return whether this client created the session with a positive budget."""
+
+        return is_cost_budget_armed_session(self, session_id)
+
     def _static_interaction_policy(self) -> dict[str, Any]:
         self._log_local_interaction_policy_once()
         return {
@@ -1568,12 +1585,18 @@ class BackendIntegratedClient:
         session_id: str,
         include_full_history: bool = False,
         certified_selection: dict[str, Any] | None = None,
+        session_aggregation: dict[str, Any] | None = None,
     ) -> OptimizationFinalizationResponse:
         """Finalize optimization session and get results.
         Delegates to session_operations module. Phase 8: an optional
-        client-attested certified-selection report (content-free)."""
+        client-attested certified-selection report (content-free).
+        Traigent#1720/#1724 (g2:agg-summary): an optional content-free
+        session-level rollup, threaded the same way."""
         return await self._session_ops.finalize_session(
-            session_id, include_full_history, certified_selection=certified_selection
+            session_id,
+            include_full_history,
+            certified_selection=certified_selection,
+            session_aggregation=session_aggregation,
         )
 
     async def delete_session(self, session_id: str, cascade: bool = True) -> bool:
@@ -1586,11 +1609,15 @@ class BackendIntegratedClient:
         session_id: str,
         include_full_history: bool = False,
         certified_selection: dict[str, Any] | None = None,
+        session_aggregation: dict[str, Any] | None = None,
     ) -> OptimizationFinalizationResponse | None:
         """Synchronous wrapper for finalize_session.
         Delegates to session_operations module."""
         return self._session_ops.finalize_session_sync(
-            session_id, include_full_history, certified_selection=certified_selection
+            session_id,
+            include_full_history,
+            certified_selection=certified_selection,
+            session_aggregation=session_aggregation,
         )
 
     def delete_session_sync(self, session_id: str, cascade: bool = True) -> bool:

{traigent-0.21.0.dev2 → traigent-0.21.1.dev0}/traigent/cloud/client.py

@@ -66,6 +66,12 @@ from .models import (
     TrialResultSubmission,
     TrialSuggestion,
 )
+from .session_budgets import (
+    ensure_cost_metric_for_budgeted_completed_submission,
+    is_cost_budget_armed_session,
+    remember_cost_budget_armed_session,
+)
+from .session_objectives import normalize_typed_objectives, session_objective_to_wire
 from .smart_pruning import normalize_smart_pruning_options
 from .subset_selection import SmartSubsetSelector
 from .url_security import validate_cloud_base_url
@@ -813,6 +819,7 @@ class TraigentCloudClient(BaseTraigentClient):
         self._session_finalizer: weakref.finalize | None = None
         # Track session ownership fingerprints for clearer error reporting
         self._session_owners: dict[str, dict[str, Any]] = {}
+        self._cost_budget_armed_sessions: set[str] = set()
 
     @property
     def _session(self) -> aiohttp.ClientSession | None:
@@ -1055,6 +1062,18 @@ class TraigentCloudClient(BaseTraigentClient):
         if owner_info:
             self._session_owners[session_id] = owner_info
 
+    def _remember_cost_budget_armed_session(
+        self, session_id: str, budget: dict[str, Any] | None
+    ) -> None:
+        """Track sessions whose typed create armed a positive cost budget."""
+
+        remember_cost_budget_armed_session(self, session_id, budget)
+
+    def _is_cost_budget_armed_session(self, session_id: str) -> bool:
+        """Return whether this client created the session with a positive budget."""
+
+        return is_cost_budget_armed_session(self, session_id)
+
     @staticmethod
     def _summarize_actor(info: dict[str, Any] | None) -> str:
         """Create a human-readable summary of a session owner or caller."""
@@ -1715,6 +1734,9 @@ class TraigentCloudClient(BaseTraigentClient):
                         dict(request.metadata or {}),
                         data.get("metadata", {}),
                     )
+                    self._remember_cost_budget_armed_session(
+                        result.session_id, request_data.get("budget")
+                    )
                     return result
                 else:
                     error_text = await response.text()
@@ -1832,6 +1854,15 @@ class TraigentCloudClient(BaseTraigentClient):
         try:
             url = f"{self.api_base_url}/sessions/{session_id}/results"
             request_data = self._serialize_trial_result(result)
+            request_data["metrics"] = dict(request_data.get("metrics") or {})
+            ensure_cost_metric_for_budgeted_completed_submission(
+                client=self,
+                session_id=session_id,
+                metrics=request_data["metrics"],
+                status=request_data.get("status"),
+                telemetry_sources=(result.metadata, request_data.get("metadata")),
+                logger=logger,
+            )
 
             async with self._aio_session.post(
                 url, json=request_data, headers=await self._get_headers()
@@ -1917,13 +1948,11 @@ class TraigentCloudClient(BaseTraigentClient):
         """Serialize session creation request."""
         metadata = self._ensure_owner_metadata(request.metadata)
         request.metadata = metadata
+        objectives_payload = normalize_typed_objectives(request.objectives)
         payload: dict[str, Any] = {
             "function_name": request.function_name,
             "configuration_space": request.configuration_space,
-            "objectives": [
-                self._serialize_session_objective(objective)
-                for objective in (request.objectives or [])
-            ],
+            "objectives": objectives_payload,
             "dataset_metadata": request.dataset_metadata,
             "max_trials": request.max_trials,
             "optimization_strategy": request.optimization_strategy,
@@ -1962,28 +1991,7 @@ class TraigentCloudClient(BaseTraigentClient):
         objective: str | SessionObjectiveDefinition | dict[str, Any],
     ) -> str | dict[str, Any]:
         """Serialize a typed objective while preserving string shorthand."""
-        if isinstance(objective, str):
-            return objective
-        if isinstance(objective, SessionObjectiveDefinition):
-            payload: dict[str, Any] = {
-                "metric": objective.metric,
-            }
-            if objective.band is not None:
-                payload["band"] = dict(objective.band)
-                if objective.test is not None:
-                    payload["test"] = objective.test
-                if objective.alpha is not None:
-                    payload["alpha"] = objective.alpha
-            elif objective.direction is not None:
-                payload["direction"] = objective.direction
-            if objective.weight is not None:
-                payload["weight"] = objective.weight
-            return payload
-        if isinstance(objective, dict):
-            return dict(objective)
-        raise TypeError(
-            "Session objectives must be strings, dicts, or SessionObjectiveDefinition objects"
-        )
+        return session_objective_to_wire(objective)
 
     def _deserialize_session_response(
         self, data: dict[str, Any]

traigent-0.21.1.dev0/traigent/cloud/session_budgets.py

@@ -0,0 +1,82 @@
+"""Session budget tracking and result cost guarantees."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+from traigent.utils.trial_costs import (
+    coerce_finite_cost,
+    extract_trial_cost_metric,
+    is_finite_numeric_cost,
+)
+
+
+def cost_budget_is_armed(budget: Any) -> bool:
+    """Return True when a session-create budget carries a positive cost cap."""
+
+    if not isinstance(budget, Mapping):
+        return False
+    max_cost = coerce_finite_cost(budget.get("max_cost_usd"))
+    return max_cost is not None and max_cost > 0
+
+
+def remember_cost_budget_armed_session(
+    client: Any, session_id: str, budget: Any
+) -> None:
+    """Record a successfully created budget-armed session on a client instance."""
+
+    sessions = getattr(client, "__dict__", {}).get("_cost_budget_armed_sessions")
+    if not isinstance(sessions, set):
+        sessions = set()
+        client._cost_budget_armed_sessions = sessions
+    if cost_budget_is_armed(budget):
+        sessions.add(session_id)
+    else:
+        sessions.discard(session_id)
+
+
+def is_cost_budget_armed_session(client: Any, session_id: str) -> bool:
+    """Return whether the client remembers a positive cost budget for a session."""
+
+    sessions = getattr(client, "__dict__", {}).get("_cost_budget_armed_sessions")
+    return isinstance(sessions, set) and session_id in sessions
+
+
+def is_completed_status(status: Any) -> bool:
+    """Return True for SDK or backend completed status tokens."""
+
+    raw_status = getattr(status, "value", status)
+    return str(raw_status or "").strip().upper() == "COMPLETED"
+
+
+def ensure_cost_metric_for_budgeted_completed_submission(
+    *,
+    client: Any,
+    session_id: str,
+    metrics: dict[str, Any],
+    status: Any,
+    telemetry_sources: tuple[Any, ...] = (),
+    logger: Any | None = None,
+) -> bool:
+    """Guarantee metrics.cost for completed submissions on budgeted sessions.
+
+    Returns True when the metrics mapping was mutated.
+    """
+
+    if not is_completed_status(status):
+        return False
+    if not is_cost_budget_armed_session(client, session_id):
+        return False
+    if is_finite_numeric_cost(metrics.get("cost")):
+        return False
+
+    cost = extract_trial_cost_metric(metrics, *telemetry_sources)
+    if cost is not None:
+        metrics["cost"] = cost
+        return True
+
+    metrics["cost"] = 0.0
+    if logger is not None:
+        logger.debug("no cost telemetry; backfilling 0.0 for budget accounting")
+    return True

traigent-0.21.1.dev0/traigent/cloud/session_objectives.py

@@ -0,0 +1,78 @@
+"""Typed session objective normalization helpers."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from traigent.cloud.models import SessionObjectiveDefinition
+
+_DIRECTION_OBJECTIVES = frozenset({"maximize", "minimize"})
+
+
+def session_objective_to_wire(
+    objective: str | SessionObjectiveDefinition | dict[str, Any],
+) -> str | dict[str, Any]:
+    """Serialize one typed objective to the session-create wire shape."""
+
+    if isinstance(objective, str):
+        return objective
+    if isinstance(objective, SessionObjectiveDefinition):
+        payload: dict[str, Any] = {"metric": objective.metric}
+        if objective.band is not None:
+            payload["band"] = dict(objective.band)
+            if objective.test is not None:
+                payload["test"] = objective.test
+            if objective.alpha is not None:
+                payload["alpha"] = objective.alpha
+        elif objective.direction is not None:
+            payload["direction"] = objective.direction
+        if objective.weight is not None:
+            payload["weight"] = objective.weight
+        return payload
+    if isinstance(objective, dict):
+        return dict(objective)
+    raise TypeError(
+        "Session objectives must be strings, dicts, or SessionObjectiveDefinition objects"
+    )
+
+
+def normalize_typed_objectives(objectives: Any) -> list[Any]:
+    """Normalize typed objective shorthands without changing legacy semantics.
+
+    Bare direction words are legacy optimization-goal placeholders, not metric
+    names. The typed session contract uses "score" for that fallback because
+    BackendSessionManager backfills the score metric before result submission.
+    """
+
+    normalized: list[Any] = []
+    seen_score_directions: set[str] = set()
+    raw_objectives = list(objectives or ["maximize"])
+
+    for raw_objective in raw_objectives:
+        objective = session_objective_to_wire(raw_objective)
+        if isinstance(objective, str):
+            direction = objective.strip().lower()
+            if direction in _DIRECTION_OBJECTIVES:
+                objective = {"metric": "score", "direction": direction}
+
+        score_direction = None
+        if isinstance(objective, dict):
+            metric = objective.get("metric")
+            direction = objective.get("direction")
+            if (
+                isinstance(metric, str)
+                and metric == "score"
+                and isinstance(direction, str)
+                and direction.lower() in _DIRECTION_OBJECTIVES
+            ):
+                score_direction = direction.lower()
+
+        if score_direction is not None:
+            if score_direction in seen_score_directions:
+                continue
+            seen_score_directions.add(score_direction)
+            objective["direction"] = score_direction
+
+        normalized.append(objective)
+
+    return normalized

{traigent-0.21.0.dev2 → traigent-0.21.1.dev0}/traigent/cloud/session_operations.py

@@ -1167,6 +1167,7 @@ class SessionOperations:
         session_id: str,
         include_full_history: bool = False,
         certified_selection: dict[str, Any] | None = None,
+        session_aggregation: dict[str, Any] | None = None,
     ) -> OptimizationFinalizationResponse:
         """Finalize optimization session and get results.
 
@@ -1176,6 +1177,10 @@ class SessionOperations:
         Args:
             session_id: Session ID to finalize
             include_full_history: Whether to include full trial history in response
+            certified_selection: Client-attested certified-selection report.
+            session_aggregation: Content-free session-level rollup payload
+                (Traigent#1720/#1724, g2:agg-summary), threaded to the
+                finalize endpoint exactly like ``certified_selection``.
 
         Returns:
             OptimizationFinalizationResponse with session summary
@@ -1227,6 +1232,7 @@ class SessionOperations:
                     session_id,
                     mapping.experiment_run_id,
                     certified_selection=certified_selection,
+                    session_aggregation=session_aggregation,
                 )
             except CloudServiceError:
                 raise
@@ -1294,6 +1300,14 @@ class SessionOperations:
         backend_convergence_history = backend_summary.get("convergence_history")
         backend_full_history = backend_summary.get("full_history")
         backend_metadata = backend_summary.get("metadata")
+        # Traigent#1720/#1724 (g2:agg-summary): the backend echoes the
+        # allowlist-normalized session_aggregation rollup back as a
+        # top-level finalize-response property (mirrors the request shape).
+        # Only surface it when it round-tripped as a dict — the SDK
+        # orchestrator uses its presence here as the honest "was this
+        # actually persisted" signal, so a malformed/missing echo must not
+        # be synthesized.
+        backend_session_aggregation = backend_summary.get("session_aggregation")
         backend_warm_start_transfer = (
             backend_metadata.get("warm_start_transfer")
             if isinstance(backend_metadata, dict)
@@ -1427,6 +1441,15 @@ class SessionOperations:
                     if isinstance(effective_warm_start_transfer, dict)
                     else {}
                 ),
+                # Traigent#1720/#1724 (g2:agg-summary): echo the backend's
+                # acknowledged session_aggregation rollup so the orchestrator
+                # can derive an honest "was this actually persisted" signal.
+                # Absent/malformed echo => key omitted (never synthesized).
+                **(
+                    {"session_aggregation": dict(backend_session_aggregation)}
+                    if isinstance(backend_session_aggregation, dict)
+                    else {}
+                ),
             },
         )
 
@@ -1437,12 +1460,16 @@ class SessionOperations:
         session_id: str,
         experiment_run_id: str,
         certified_selection: dict[str, Any] | None = None,
+        session_aggregation: dict[str, Any] | None = None,
     ) -> dict[str, Any] | None:
         """Call backend session finalization endpoint.
 
         Args:
             session_id: Session ID to finalize
             experiment_run_id: Associated experiment run ID
+            certified_selection: Client-attested certified-selection report.
+            session_aggregation: Content-free session-level rollup payload
+                (Traigent#1720/#1724, g2:agg-summary).
 
         Returns:
             Parsed backend response payload (may be ``{}`` if the backend
@@ -1484,6 +1511,27 @@ class SessionOperations:
                     # selection report — TOP-LEVEL key only (the backend
                     # rejects metadata-tunneled reports).
                     finalize_body["certified_selection"] = certified_selection
+                if session_aggregation is not None:
+                    # Traigent#1720/#1724 (g2:agg-summary): the content-free
+                    # session-level rollup — TOP-LEVEL key only, mirroring
+                    # certified_selection immediately above (the backend
+                    # rejects metadata-tunneled payloads).
+                    #
+                    # EGRESS GUARD (Codex round 6): re-sanitize here, at the
+                    # true wire boundary, so a caller-supplied dict passed to
+                    # finalize_session(..., session_aggregation=...) that
+                    # bypassed the builder cannot leak unbounded content. The
+                    # builder's output is already bounded, so this is a no-op
+                    # on the normal path. Lazy import avoids an import cycle.
+                    from traigent.core.backend_session_manager import (
+                        sanitize_session_aggregation_payload,
+                    )
+
+                    sanitized_aggregation = sanitize_session_aggregation_payload(
+                        session_aggregation
+                    )
+                    if sanitized_aggregation is not None:
+                        finalize_body["session_aggregation"] = sanitized_aggregation
                 async with session.post(
                     url,
                     json=finalize_body,
@@ -1631,6 +1679,7 @@ class SessionOperations:
         session_id: str,
         include_full_history: bool = False,
         certified_selection: dict[str, Any] | None = None,
+        session_aggregation: dict[str, Any] | None = None,
     ) -> OptimizationFinalizationResponse | None:
         """Synchronous wrapper for finalize_session."""
         import concurrent.futures
@@ -1647,6 +1696,7 @@ class SessionOperations:
                         session_id,
                         include_full_history,
                         certified_selection=certified_selection,
+                        session_aggregation=session_aggregation,
                     )
                 )
             finally:

{traigent-0.21.0.dev2 → traigent-0.21.1.dev0}/traigent/cloud/sync_manager.py

@@ -320,6 +320,12 @@ class SyncManager:
             session.trials or []
         )
         objectives = self._derive_objectives(opt_config, configuration_runs)
+        # Guard: the backend rejects a COMPLETED trial whose metrics lack any
+        # declared objective. Backfill each completed trial's measures so every
+        # objective is present as a number (prefer its own ``score``, else 0.0),
+        # so a real user-declared objective missing from one trial can't 400 the
+        # whole sync.
+        self._backfill_objective_measures(configuration_runs, objectives)
 
         # Content-free dataset label: name + size only, never example content.
         # The typed path validates dataset_metadata.size as a positive int
@@ -377,18 +383,54 @@ class SyncManager:
     def _derive_objectives(
         opt_config: dict[str, Any], configuration_runs: list[dict[str, Any]]
     ) -> list[str]:
-        """Derive objective names for the typed session create payload.
-
-        Prefer the objectives recorded on the local optimization config; fall
-        back to the measure names present on the trials (``["score"]`` at
-        minimum). Content-free: only measure/objective *names* are emitted.
+        """Derive the session's objective names for the typed create payload.
+
+        The backend requires EVERY declared objective to be present as a numeric
+        metric on EVERY completed trial (an Optuna objective must be a scalar it
+        can ``tell()``). So the objective set must be MINIMAL and universally
+        present, NOT the union of every incidental per-trial measure — declaring
+        the union makes run-level overlays (``run_trials_completed``,
+        ``duration``, tokens, cost, ...) "required objectives" that not every
+        trial reports, and each such trial's /results then 400s
+        ("Completed trial is missing numeric metric ...").
+
+        Prefer the run's real optimization objectives; otherwise fall back to
+        ``["score"]`` — ``score`` is written on every trial by
+        ``_convert_trials_to_results``, so it is guaranteed present. The caller
+        additionally backfills any declared objective missing from a completed
+        trial (see ``convert_session_to_traigent_format``). Content-free: only
+        objective *names* are emitted.
         """
         raw_objectives = opt_config.get("objectives")
         if isinstance(raw_objectives, (list, tuple)):
             names = [str(name) for name in raw_objectives if name]
             if names:
                 return names
-        return SyncManager._derive_experiment_measures(configuration_runs)
+        return ["score"]
+
+    @staticmethod
+    def _backfill_objective_measures(
+        configuration_runs: list[dict[str, Any]], objectives: list[str]
+    ) -> None:
+        """Ensure every COMPLETED trial reports each declared objective numerically.
+
+        The backend requires a numeric value for every objective on a completed
+        trial (Optuna ``tell``). If a trial's measures omit one (or it is
+        non-numeric), backfill it with the trial's ``score`` when available, else
+        ``0.0``. Only completed trials are guarded — failed trials skip the
+        objective check server-side. Mutates ``configuration_runs`` in place.
+        """
+        for configuration_run in configuration_runs:
+            if str(configuration_run.get("status", "")).upper() != "COMPLETED":
+                continue
+            measures = configuration_run.setdefault("measures", {})
+            fallback = measures.get("score")
+            if not isinstance(fallback, (int, float)) or isinstance(fallback, bool):
+                fallback = 0.0
+            for objective in objectives:
+                value = measures.get(objective)
+                if not isinstance(value, (int, float)) or isinstance(value, bool):
+                    measures[objective] = fallback
 
     def _convert_trials_to_configuration_runs(
         self, trials: list[Any]
@@ -453,19 +495,6 @@ class SyncManager:
         """Return True for JSON numeric values while excluding booleans."""
         return isinstance(value, (int, float)) and not isinstance(value, bool)
 
-    @staticmethod
-    def _derive_experiment_measures(
-        configuration_runs: list[dict[str, Any]],
-    ) -> list[str]:
-        """Derive the experiment-level measure list from trial payloads."""
-        measures: list[str] = []
-        for configuration_run in configuration_runs:
-            for measure_name in configuration_run.get("measures", {}):
-                if measure_name not in measures:
-                    measures.append(measure_name)
-
-        return measures or ["score"]
-
     def _convert_trials_to_results(self, trials: list[Any]) -> list[dict[str, Any]]:
         """Convert local trials to Traigent configuration_run format."""
         results = []

{traigent-0.21.0.dev2 → traigent-0.21.1.dev0}/traigent/cloud/trial_operations.py

@@ -22,6 +22,9 @@ from traigent.cloud.client import (
     raise_if_cloud_egress_disabled,
 )
 from traigent.cloud.dtos import MeasuresDict
+from traigent.cloud.session_budgets import (
+    ensure_cost_metric_for_budgeted_completed_submission,
+)
 from traigent.cloud.validators import validate_configuration_run_submission
 from traigent.config.backend_config import BackendConfig
 from traigent.utils.env_config import is_backend_offline, resolve_environment_label
@@ -989,6 +992,15 @@ class TrialOperations:
                 )
                 return False
 
+            ensure_cost_metric_for_budgeted_completed_submission(
+                client=self.client,
+                session_id=session_id,
+                metrics=validated_metrics,
+                status=backend_status,
+                telemetry_sources=(metrics, metadata, measures, summary_stats),
+                logger=logger,
+            )
+
             # Build result data
             result_data = self._build_trial_result_data(
                 trial_id,
@@ -1169,6 +1181,16 @@ class TrialOperations:
                 # Also include summary_stats for backend to detect privacy mode
                 "summary_stats": summary_stats,
             }
+            submission_metrics = submission_data["metrics"]
+            if isinstance(submission_metrics, dict):
+                ensure_cost_metric_for_budgeted_completed_submission(
+                    client=self.client,
+                    session_id=session_id,
+                    metrics=submission_metrics,
+                    status=backend_status,
+                    telemetry_sources=(summary_stats, submission_metadata),
+                    logger=logger,
+                )
 
             # Validate the submission data. Schema validation is authoritative;
             # invalid payloads must not be posted to the backend.