traigent 0.18.1.dev5__tar.gz → 0.18.1.dev7__tar.gz

{traigent-0.18.1.dev5/traigent.egg-info → traigent-0.18.1.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: traigent
-Version: 0.18.1.dev5
+Version: 0.18.1.dev7
 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.18.1.dev5 → traigent-0.18.1.dev7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "traigent"
-version = "0.18.1.dev5"
+version = "0.18.1.dev7"
 authors = [
     {name = "Traigent Team", email = "opensource@traigent.ai"},
 ]

{traigent-0.18.1.dev5 → traigent-0.18.1.dev7}/traigent/api/decorators.py

@@ -70,6 +70,10 @@ from traigent.api.strategy_presets import (
     normalize_strategy_preset,
 )
 from traigent.api.types import AgentDefinition
+from traigent.cloud.smart_pruning import SmartPruningOptions
+from traigent.cloud.smart_pruning import (
+    normalize_smart_pruning_options as _normalize_smart_pruning_options,
+)
 from traigent.config.parallel import (
     ParallelConfig,
     coerce_parallel_config,
@@ -111,6 +115,7 @@ __all__ = [
     "HybridAPIOptions",
     "ExternalServiceEvaluator",
     "ExecutionOptions",
+    "SmartPruningOptions",
     "MockModeOptions",
     "optimize",
 ]
@@ -215,6 +220,9 @@ class ExecutionOptions(BaseModel):
         parallel_config: Configuration for parallel execution.
         max_total_examples: Maximum total examples across all trials.
         samples_include_pruned: Whether to include pruned trials in sample count.
+        smart_pruning: Optional cloud-side pruning profile. When configured on a
+            managed/cloud run, the SDK reports content-free per-example progress
+            to the backend and honors prune decisions.
         reps_per_trial: Number of repetitions per configuration for statistical
             stability. Only the default ``1`` (no repetition) is available in the
             OSS SDK; passing any other value raises ``pydantic.ValidationError`` at
@@ -248,6 +256,7 @@ class ExecutionOptions(BaseModel):
     parallel_config: ParallelConfig | dict[str, Any] | None = None
     max_total_examples: int | None = None
     samples_include_pruned: bool = True
+    smart_pruning: SmartPruningOptions | dict[str, Any] | None = None
     reps_per_trial: int = 1
     reps_aggregation: str = "mean"
 
@@ -295,7 +304,7 @@ class ExecutionOptions(BaseModel):
     @field_validator("algorithm")
     @classmethod
     def _validate_algorithm(cls, v: str) -> str:
-        return validate_algorithm_name(v)
+        return cast(str, validate_algorithm_name(v))
 
     @field_validator("offline")
     @classmethod
@@ -556,6 +565,7 @@ _OPTIMIZE_DEFAULTS: dict[str, Any] = {
     "parallel_config": None,
     "max_total_examples": None,
     "samples_include_pruned": True,
+    "smart_pruning": None,
     "mock_mode_config": None,
     "custom_evaluator": None,
     "scoring_function": None,
@@ -1258,6 +1268,7 @@ class ResolvedExecutionOptions:
     parallel_config: Any
     max_total_examples: Any
     samples_include_pruned: Any
+    smart_pruning: Any
     legacy_options: dict[str, Any] = field(default_factory=dict)
 
 
@@ -1352,6 +1363,12 @@ def _resolve_execution_bundle_options(
             execution_bundle.samples_include_pruned,
             defaults,
         ),
+        smart_pruning=_resolve_option(
+            "smart_pruning",
+            base_options.smart_pruning,
+            execution_bundle.smart_pruning,
+            defaults,
+        ),
         legacy_options=legacy_options,
     )
 
@@ -1546,7 +1563,7 @@ def _runtime_algorithm_for_policy(
         policy.intent is ExecutionIntent.LOCAL_ONLY or external_evaluator is not None
     ):
         return "random"
-    return policy.algorithm
+    return cast(str, policy.algorithm)
 
 
 def _runtime_execution_mode_for_policy(
@@ -2107,6 +2124,7 @@ def optimize(  # NOSONAR(S107)
     offline: bool = False,
     strategy: str | None = None,
     strategy_params: Mapping[str, Any] | None = None,
+    smart_pruning: SmartPruningOptions | dict[str, Any] | None = None,
     # Multi-agent configuration
     agents: dict[str, AgentDefinition] | None = None,
     agent_prefixes: list[str] | None = None,
@@ -2235,6 +2253,11 @@ def optimize(  # NOSONAR(S107)
                 or dict). Preferred path for controlling concurrency.
             max_total_examples: Global sample budget across all trials.
             samples_include_pruned: Whether pruned trials count toward the sample budget.
+            smart_pruning: Optional cloud smart-pruning profile. Accepts a dict or
+                ``SmartPruningOptions`` matching
+                ``optimization/smart_pruning_schema.json``. The SDK sends it on
+                session creation and emits content-free intermediate reports only
+                for managed/cloud runs.
 
         Mock mode options:
             mock: Grouped mock-mode preferences (MockModeOptions or dict).
@@ -2438,6 +2461,7 @@ def optimize(  # NOSONAR(S107)
         "mock": mock,
         "algorithm": algorithm,
         "offline": offline,
+        "smart_pruning": smart_pruning,
         "agents": agents,
         "agent_prefixes": agent_prefixes,
         "agent_measures": agent_measures,
@@ -2529,6 +2553,7 @@ def optimize(  # NOSONAR(S107)
     parallel_config = combined_settings["parallel_config"]
     max_total_examples = combined_settings["max_total_examples"]
     samples_include_pruned = combined_settings["samples_include_pruned"]
+    smart_pruning_value = combined_settings["smart_pruning"]
     mock_mode_config = combined_settings["mock_mode_config"]
     custom_evaluator = combined_settings["custom_evaluator"]
     scoring_function = combined_settings["scoring_function"]
@@ -2639,6 +2664,7 @@ def optimize(  # NOSONAR(S107)
         parallel_config=parallel_config,
         max_total_examples=max_total_examples,
         samples_include_pruned=samples_include_pruned,
+        smart_pruning=smart_pruning_value,
         legacy_options=legacy_execution_options,
     )
     resolved_execution = _resolve_execution_bundle_options(
@@ -2656,7 +2682,9 @@ def optimize(  # NOSONAR(S107)
     parallel_config = resolved_execution.parallel_config
     max_total_examples = resolved_execution.max_total_examples
     samples_include_pruned = resolved_execution.samples_include_pruned
+    smart_pruning_value = resolved_execution.smart_pruning
     legacy_execution_options = resolved_execution.legacy_options
+    smart_pruning_config = _normalize_smart_pruning_options(smart_pruning_value)
     external_service_evaluator = _resolve_external_service_evaluator(
         evaluator_value,
         legacy_execution_options,
@@ -2894,6 +2922,7 @@ def optimize(  # NOSONAR(S107)
             minimal_logging=minimal_logging,
             max_total_examples=max_total_examples,
             samples_include_pruned=samples_include_pruned,
+            smart_pruning=smart_pruning_config,
             parallel_config=combined_parallel_config,
             mock_mode_config=mock_mode_config,
             custom_evaluator=custom_evaluator,

{traigent-0.18.1.dev5 → traigent-0.18.1.dev7}/traigent/cloud/api_operations.py

@@ -30,6 +30,10 @@ from traigent.cloud.models import (
     SessionCreationResponse,
     TrialResultSubmission,
 )
+from traigent.cloud.smart_pruning import (
+    normalize_intermediate_report_payload,
+    normalize_smart_pruning_options,
+)
 from traigent.config.backend_config import BackendConfig
 from traigent.core.session_types import (
     SessionCreationFailureDetail,
@@ -661,6 +665,10 @@ class ApiOperations:
             payload["tvl_governance"] = wire_governance
         if getattr(session_request, "warm_start_from", None):
             payload["warm_start_from"] = session_request.warm_start_from
+        smart_pruning = getattr(session_request, "smart_pruning", None)
+        wire_smart_pruning = normalize_smart_pruning_options(smart_pruning)
+        if wire_smart_pruning:
+            payload["smart_pruning"] = wire_smart_pruning
         self._attach_artifact_fingerprint_payload(payload, session_request)
         return payload
 
@@ -705,6 +713,10 @@ class ApiOperations:
         # BE may not consume it yet; the SDK must still forward it.
         if getattr(session_request, "warm_start_from", None):
             payload["warm_start_from"] = session_request.warm_start_from
+        smart_pruning = getattr(session_request, "smart_pruning", None)
+        wire_smart_pruning = normalize_smart_pruning_options(smart_pruning)
+        if wire_smart_pruning:
+            payload["smart_pruning"] = wire_smart_pruning
         self._attach_artifact_fingerprint_payload(payload, session_request)
         return payload
 
@@ -797,6 +809,75 @@ class ApiOperations:
         normalized = str(value).strip()
         return normalized or None
 
+    async def report_intermediate_progress(
+        self, payload: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Report per-trial intermediate progress for cloud smart pruning."""
+        wire_payload = normalize_intermediate_report_payload(payload)
+        session_id = str(wire_payload.get("session_id", "")).strip()
+        trial_id = str(wire_payload.get("trial_id", "")).strip()
+        if not session_id or not trial_id:
+            return {"prune": False, "prune_reason": None}
+        if is_backend_offline():
+            logger.debug(
+                "Offline mode: skipping intermediate report for session %s trial %s",
+                session_id,
+                trial_id,
+            )
+            return {"prune": False, "prune_reason": None}
+
+        self._raise_if_backend_egress_disabled("intermediate report")
+        if not AIOHTTP_AVAILABLE:
+            logger.debug("aiohttp not available, skipping intermediate report")
+            return {"prune": False, "prune_reason": None}
+
+        try:
+            headers = await self.client.auth_manager.augment_headers(
+                {"Content-Type": _JSON_CONTENT_TYPE}
+            )
+            async with cast(Any, aiohttp).ClientSession(
+                connector=self._build_connector()
+            ) as session:
+                api_base = (
+                    self.client.backend_config.api_base_url
+                    or BackendConfig.get_backend_api_url()
+                )
+                url = f"{api_base}/sessions/{session_id}/intermediate-report"
+                timeout = cast(Any, aiohttp).ClientTimeout(total=10)
+                async with session.post(
+                    url,
+                    json=wire_payload,
+                    headers=headers,
+                    timeout=timeout,
+                ) as response:
+                    if response.status == 200:
+                        decision = await response.json()
+                        if isinstance(decision, dict):
+                            return {
+                                "prune": bool(decision.get("prune", False)),
+                                "prune_reason": decision.get("prune_reason"),
+                            }
+                        return {"prune": False, "prune_reason": None}
+
+                    error_msg = await response.text()
+                    logger.debug(
+                        "Intermediate report rejected for session %s trial %s: "
+                        "HTTP %s %s",
+                        session_id,
+                        trial_id,
+                        response.status,
+                        error_msg[:300],
+                    )
+                    return {"prune": False, "prune_reason": None}
+        except aiohttp.ClientError as exc:
+            logger.debug(
+                "Network error sending intermediate report for session %s trial %s: %s",
+                session_id,
+                trial_id,
+                exc,
+            )
+            return {"prune": False, "prune_reason": None}
+
     def _handle_session_error(self, status_code: int, error_msg: str) -> None:
         """Raise structured exceptions for non-success HTTP responses.
 

{traigent-0.18.1.dev5 → traigent-0.18.1.dev7}/traigent/cloud/backend_client.py

@@ -584,6 +584,7 @@ class BackendIntegratedClient:
 
         self.enable_fallback = enable_fallback
         self.no_egress = bool(no_egress)
+        self.cloud_egress_intent = False
         self._api_key_fallback = api_key
         self.enable_rate_limiting = enable_rate_limiting
         self.rate_limit_calls = rate_limit_calls
@@ -1285,8 +1286,11 @@ class BackendIntegratedClient:
     ) -> TrialSuggestion | None:
         """Get next trial suggestion for privacy-first optimization.
         Delegates to privacy_operations module."""
-        return await self._privacy_ops.get_next_privacy_trial(
-            session_id, previous_results
+        return cast(
+            TrialSuggestion | None,
+            await self._privacy_ops.get_next_privacy_trial(
+                session_id, previous_results
+            ),
         )
 
     async def submit_privacy_trial_results(
@@ -1319,8 +1323,16 @@ class BackendIntegratedClient:
     ) -> AgentOptimizationResponse:
         """Start reserved cloud agent optimization.
         Delegates to cloud_operations module."""
-        return await self._cloud_ops.start_agent_optimization(
-            agent_spec, dataset, configuration_space, objectives, max_trials, user_id
+        return cast(
+            AgentOptimizationResponse,
+            await self._cloud_ops.start_agent_optimization(
+                agent_spec,
+                dataset,
+                configuration_space,
+                objectives,
+                max_trials,
+                user_id,
+            ),
         )
 
     async def execute_agent(
@@ -1331,8 +1343,11 @@ class BackendIntegratedClient:
     ) -> AgentExecutionResponse:
         """Execute agent through the reserved cloud path.
         Delegates to cloud_operations module."""
-        return await self._cloud_ops.execute_agent(
-            agent_spec, input_data, config_overrides
+        return cast(
+            AgentExecutionResponse,
+            await self._cloud_ops.execute_agent(
+                agent_spec, input_data, config_overrides
+            ),
         )
 
     # Session Operations
@@ -1348,6 +1363,7 @@ class BackendIntegratedClient:
         warm_start_from: str | None = None,
         artifact_fingerprints: dict[str, str | None] | None = None,
         fingerprint_meta: dict[str, Any] | None = None,
+        smart_pruning: dict[str, Any] | None = None,
     ) -> SessionCreationResult:
         """Synchronous wrapper for creating a session.
         Delegates to session_operations module. Phase 8: objectives are
@@ -1364,6 +1380,7 @@ class BackendIntegratedClient:
             warm_start_from=warm_start_from,
             artifact_fingerprints=artifact_fingerprints,
             fingerprint_meta=fingerprint_meta,
+            smart_pruning=smart_pruning,
         )
 
     async def create_hybrid_session(
@@ -2059,6 +2076,15 @@ class BackendIntegratedClient:
             await self._api_ops.update_config_run_status(config_run_id, status),
         )
 
+    async def _report_intermediate_progress(
+        self, payload: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Report intermediate trial progress for smart pruning."""
+        return cast(
+            dict[str, Any],
+            await self._api_ops.report_intermediate_progress(payload),
+        )
+
     async def _update_config_run_measures(
         self,
         config_run_id: str,

{traigent-0.18.1.dev5 → traigent-0.18.1.dev7}/traigent/cloud/client.py

@@ -10,7 +10,7 @@ import os
 import time
 import weakref
 from abc import ABC, abstractmethod
-from collections.abc import Callable, Mapping, Sequence
+from collections.abc import Awaitable, Callable, Mapping, Sequence
 from dataclasses import dataclass
 from importlib import import_module
 from typing import Any, NoReturn, cast
@@ -33,13 +33,13 @@ else:  # pragma: no cover - minimal environments without aiohttp
 
 from traigent.config.backend_config import BackendConfig
 from traigent.evaluators.base import Dataset
-from traigent.utils.env_config import is_backend_offline
-from traigent.utils.error_handler import OfflineModeError
-from traigent.utils.error_handler import TraigentError as HelpfulTraigentError
 from traigent.utils.artifact_fingerprints import (
     artifact_fingerprints_to_wire,
     fingerprint_meta_to_wire,
 )
+from traigent.utils.env_config import is_backend_offline
+from traigent.utils.error_handler import OfflineModeError
+from traigent.utils.error_handler import TraigentError as HelpfulTraigentError
 from traigent.utils.exceptions import ValidationError as ValidationException
 from traigent.utils.logging import get_logger
 from traigent.utils.retry import NetworkError, RateLimitError, retry_http_request
@@ -62,9 +62,11 @@ from .models import (
     SessionCreationRequest,
     SessionCreationResponse,
     SessionObjectiveDefinition,
+    SessionSummary,
     TrialResultSubmission,
     TrialSuggestion,
 )
+from .smart_pruning import normalize_smart_pruning_options
 from .subset_selection import SmartSubsetSelector
 from .url_security import validate_cloud_base_url
 
@@ -130,7 +132,7 @@ def _session_is_closed(session: Any) -> bool:
     return False
 
 
-def _log_finalizer_close_task_result(task: asyncio.Task[Any], owner: str) -> None:
+def _log_finalizer_close_task_result(task: asyncio.Future[Any], owner: str) -> None:
     try:
         task.result()
     except asyncio.CancelledError:
@@ -162,7 +164,10 @@ def _schedule_aiohttp_session_close(
         try:
             close_result = close_method()
             if inspect.isawaitable(close_result):
-                task = loop.create_task(close_result)
+                task: asyncio.Future[Any] = asyncio.ensure_future(
+                    cast(Awaitable[Any], close_result),
+                    loop=loop,
+                )
                 task.add_done_callback(
                     lambda done_task: _log_finalizer_close_task_result(done_task, owner)
                 )
@@ -1517,8 +1522,16 @@ class TraigentCloudClient(BaseTraigentClient):
                 f"Failed to finalize session: {e}", "session_finalization", e
             ) from e
 
-    async def delete_session(self, session_id: str, cascade: bool = True) -> bool:
-        """Delete a session using the backend cleanup endpoint."""
+    async def delete_session(self, session_id: str, cascade: bool = False) -> bool:
+        """Delete a session via ``DELETE /api/v1/sessions/<id>``.
+
+        Non-destructive by default (``cascade=False``), matching the backend
+        default: only the session and its run artifacts are removed. Pass
+        ``cascade=True`` to additionally hard-delete the parent experiment when
+        the deleted session was its last run. Use this with
+        :meth:`list_sessions` to enumerate and clean up orphaned / zombie
+        "running" sessions from the client.
+        """
         if not session_id:
             raise ValueError("session_id is required")
 
@@ -1556,6 +1569,68 @@ class TraigentCloudClient(BaseTraigentClient):
                 f"Failed to delete session: {exc}", "session_delete", exc
             ) from exc
 
+    async def list_sessions(
+        self,
+        status: str | None = None,
+        pattern: str | None = None,
+        limit: int | None = None,
+    ) -> list[SessionSummary]:
+        """List sessions via ``GET /api/v1/sessions``.
+
+        Enumerates the caller's optimization sessions so orphaned / zombie
+        "running" sessions can be found and cleaned up with
+        :meth:`delete_session`. Returns typed :class:`SessionSummary` objects.
+
+        Args:
+            status: Optional lifecycle filter (server-side ``status`` query param).
+            pattern: Optional session-id match (server-side ``pattern`` query
+                param).
+            limit: Optional cap on the number of summaries returned. The backend
+                does not support a server-side limit, so this is applied
+                client-side after the response is received.
+
+        Returns:
+            A list of :class:`SessionSummary` (empty when there are none).
+        """
+        self._raise_if_backend_egress_disabled("list sessions")
+        await self._ensure_session()
+        if self._aio_session is None:
+            raise CloudServiceError(_SESSION_NOT_INITIALIZED)
+
+        params: dict[str, str] = {}
+        if status is not None:
+            params["status"] = str(status)
+        if pattern is not None:
+            params["pattern"] = str(pattern)
+
+        url = f"{self.api_base_url}/sessions"
+        try:
+            async with self._aio_session.get(url, params=params) as response:
+                if response.status != 200:
+                    error_text = await response.text()
+                    raise CloudServiceError(
+                        f"Failed to list sessions: status={response.status} "
+                        f"body={error_text[:200]}"
+                    )
+                data = await response.json()
+        except aiohttp.ClientError as exc:
+            await self._reset_http_session("list_sessions network error")
+            raise StandardizedClientError(
+                f"Failed to list sessions: {exc}", "session_list", exc
+            ) from exc
+
+        raw_sessions = data.get("sessions") if isinstance(data, dict) else None
+        if not isinstance(raw_sessions, list):
+            raw_sessions = []
+        summaries = [
+            SessionSummary.from_dict(item)
+            for item in raw_sessions
+            if isinstance(item, dict)
+        ]
+        if limit is not None and limit >= 0:
+            summaries = summaries[:limit]
+        return summaries
+
     # Stateful optimization methods for interactive model
 
     async def create_optimization_session(
@@ -1865,6 +1940,9 @@ class TraigentCloudClient(BaseTraigentClient):
         # Warm-start: prior experiment id (empty string treated as absent).
         if request.warm_start_from:
             payload["warm_start_from"] = request.warm_start_from
+        smart_pruning = normalize_smart_pruning_options(request.smart_pruning)
+        if smart_pruning:
+            payload["smart_pruning"] = smart_pruning
         artifact_fingerprints = artifact_fingerprints_to_wire(
             getattr(request, "artifact_fingerprints", None)
         )

{traigent-0.18.1.dev5 → traigent-0.18.1.dev7}/traigent/cloud/models.py

@@ -19,6 +19,7 @@ from typing import Any
 # enum lives in ``traigent.api.types``. Re-export it here so the cloud layer and
 # the public API can never drift into two disagreeing ``TrialStatus`` enums.
 from traigent.api.types import TrialStatus as TrialStatus
+from traigent.cloud.smart_pruning import normalize_smart_pruning_options
 from traigent.evaluators.base import Dataset
 
 
@@ -139,6 +140,40 @@ class OptimizationSession:
         )
 
 
+@dataclass
+class SessionSummary:
+    """Lightweight summary of a session from ``GET /api/v1/sessions``.
+
+    Returned by :meth:`traigent.cloud.client.TraigentCloudClient.list_sessions`.
+    Maps the backend session-list contract
+    (``optimization/optimization_session_list_response_schema.json``):
+    ``session_id`` and
+    ``status`` are always present; ``created_at`` / ``progress`` when the server
+    provides them. Forward-compatible — any additional server fields are kept in
+    ``extra`` rather than dropped, so the SDK can enumerate and clean up orphaned
+    sessions without a release per new field.
+    """
+
+    session_id: str
+    status: str
+    created_at: str | None = None
+    progress: dict[str, Any] | None = None
+    extra: dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> SessionSummary:
+        """Build a summary from one backend session object, tolerating extras."""
+        known = {"session_id", "status", "created_at", "progress"}
+        progress = data.get("progress")
+        return cls(
+            session_id=str(data.get("session_id", "")),
+            status=str(data.get("status", "")),
+            created_at=data.get("created_at"),
+            progress=progress if isinstance(progress, dict) else None,
+            extra={k: v for k, v in data.items() if k not in known},
+        )
+
+
 @dataclass
 class DatasetSubsetIndices:
     """Indices for selecting a subset of the dataset."""
@@ -194,6 +229,7 @@ class SessionCreationRequest:
     constraints: dict[str, Any] | None = None
     default_config: dict[str, Any] | None = None
     warm_start_from: str | None = None
+    smart_pruning: dict[str, Any] | None = None
     promotion_policy: dict[str, Any] | None = None
     # Content-free TVL governance summary (RFC 0001 P8): cvar names/types/
     # governed flags only — built by traigent.cloud.governance, never ad hoc.
@@ -217,6 +253,7 @@ class SessionCreationRequest:
             self.objectives: list[Any] = []
         if self.dataset_metadata is None:
             self.dataset_metadata: dict[str, Any] = {"size": 100, "type": "test"}
+        self.smart_pruning = normalize_smart_pruning_options(self.smart_pruning)
         # Ensure max_trials is never None
         if self.max_trials is None:
             self.max_trials = 10

{traigent-0.18.1.dev5 → traigent-0.18.1.dev7}/traigent/cloud/session_operations.py

@@ -33,6 +33,7 @@ from traigent.cloud.session_types import (
     SessionCreationFailureReason,
     SessionCreationResult,
 )
+from traigent.cloud.smart_pruning import normalize_smart_pruning_options
 from traigent.config.backend_config import BackendConfig
 from traigent.utils.env_config import is_backend_offline, resolve_environment_label
 from traigent.utils.exceptions import ValidationError as ValidationException
@@ -367,7 +368,7 @@ class SessionOperations:
                     },
                 )
                 logger.debug("Created local fallback session: %s", session_id)
-                return session_id
+                return cast(str, session_id)
             except Exception as storage_e:
                 logger.debug("Local storage fallback failed: %s", storage_e)
 
@@ -498,6 +499,7 @@ class SessionOperations:
         promotion_policy: dict[str, Any] | None = None,
         tvl_governance: dict[str, Any] | None = None,
         warm_start_from: str | None = None,
+        smart_pruning: dict[str, Any] | None = None,
         artifact_fingerprints: dict[str, str | None] | None = None,
         fingerprint_meta: dict[str, Any] | None = None,
     ) -> SessionCreationResult:
@@ -521,6 +523,7 @@ class SessionOperations:
         self._validate_non_empty_string(optimization_goal, "optimization_goal")
         if metadata is not None and not isinstance(metadata, dict):
             raise ValidationException("metadata must be a dictionary if provided")
+        normalized_smart_pruning = normalize_smart_pruning_options(smart_pruning)
 
         # Phase 8 (review round 2): the local-availability fallback is for
         # NON-governed sessions only. A governed/strict session that cannot
@@ -629,6 +632,7 @@ class SessionOperations:
                 # reading objectives[0] as its optimization_goal).
                 objectives=list(objectives) if objectives else [optimization_goal],
                 warm_start_from=warm_start_from or None,
+                smart_pruning=normalized_smart_pruning,
                 dataset_metadata={
                     "size": metadata.get("dataset_size", 0) if metadata else 0,
                     # Carry the dataset label (content is not submitted) so the
@@ -1587,7 +1591,9 @@ class SessionOperations:
     def get_active_sessions(self) -> dict[str, OptimizationSession]:
         """Get all active optimization sessions."""
         with self.client._active_sessions_lock:
-            return self.client._active_sessions.copy()
+            return cast(
+                dict[str, OptimizationSession], self.client._active_sessions.copy()
+            )
 
     def get_session_mapping(self, session_id: str) -> SessionExperimentMapping | None:
         """Get session to experiment mapping."""