traigent 0.18.1.dev6__tar.gz → 0.18.1.dev8__tar.gz

{traigent-0.18.1.dev6/traigent.egg-info → traigent-0.18.1.dev8}/PKG-INFO

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

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

{traigent-0.18.1.dev6 → traigent-0.18.1.dev8}/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.dev6 → traigent-0.18.1.dev8}/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.dev6 → traigent-0.18.1.dev8}/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.dev6 → traigent-0.18.1.dev8}/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
@@ -66,6 +66,7 @@ from .models import (
     TrialResultSubmission,
     TrialSuggestion,
 )
+from .smart_pruning import normalize_smart_pruning_options
 from .subset_selection import SmartSubsetSelector
 from .url_security import validate_cloud_base_url
 
@@ -131,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:
@@ -163,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)
                 )
@@ -1936,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.dev6 → traigent-0.18.1.dev8}/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
 
 
@@ -228,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.
@@ -251,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.dev6 → traigent-0.18.1.dev8}/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."""

traigent-0.18.1.dev8/traigent/cloud/smart_pruning.py

@@ -0,0 +1,85 @@
+"""Smart-pruning wire contract helpers."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Literal, cast
+
+from pydantic import BaseModel, ConfigDict, Field
+from pydantic import ValidationError as PydanticValidationError
+
+
+class SmartPruningOptions(BaseModel):
+    """Cloud smart-pruning profile sent on session creation."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True, extra="forbid")
+
+    label: Literal["aggressive", "balanced", "conservative"]
+    min_completed_trials: int | None = Field(default=None, ge=1)
+    warmup_steps: int | None = Field(default=None, ge=0)
+    epsilon: float | None = Field(default=None, ge=0)
+    cost_threshold: float | None = Field(default=None, ge=0)
+    confidence: float | None = Field(default=None, gt=0, lt=1)
+    min_samples_per_config: int | None = Field(default=None, ge=1)
+    warmup_trials: int | None = Field(default=None, ge=0)
+
+
+def normalize_smart_pruning_options(
+    value: Any,
+    *,
+    field_name: str = "smart_pruning",
+) -> dict[str, Any] | None:
+    """Normalize smart-pruning config to the schema-shaped wire dict."""
+    if value is None:
+        return None
+    if isinstance(value, SmartPruningOptions):
+        model = value
+    elif isinstance(value, Mapping):
+        try:
+            model = SmartPruningOptions.model_validate(dict(value))
+        except PydanticValidationError as exc:
+            extra_keys = sorted(
+                str(error["loc"][0])
+                for error in exc.errors()
+                if error.get("type") == "extra_forbidden" and error.get("loc")
+            )
+            extra_message = (
+                f" contains unsupported key(s): {', '.join(extra_keys)};"
+                if extra_keys
+                else ""
+            )
+            raise ValueError(
+                f"{field_name}{extra_message} "
+                f"does not match smart_pruning_schema.json: {exc}"
+            ) from exc
+    else:
+        raise TypeError(
+            f"{field_name} must be a mapping or SmartPruningOptions, "
+            f"got {type(value).__name__}"
+        )
+    return cast(dict[str, Any], model.model_dump(exclude_none=True))
+
+
+_INTERMEDIATE_REPORT_KEYS = frozenset(
+    {
+        "session_id",
+        "trial_id",
+        "running_score",
+        "examples_attempted",
+        "objective_name",
+        "partial_cost_usd",
+    }
+)
+
+
+def normalize_intermediate_report_payload(
+    payload: Mapping[str, Any],
+) -> dict[str, Any]:
+    """Return an allowlisted intermediate-report payload."""
+    unknown_keys = sorted(set(payload) - _INTERMEDIATE_REPORT_KEYS)
+    if unknown_keys:
+        joined = ", ".join(unknown_keys)
+        raise ValueError(
+            f"intermediate report payload contains unsupported key(s): {joined}"
+        )
+    return {key: payload[key] for key in payload}

{traigent-0.18.1.dev6 → traigent-0.18.1.dev8}/traigent/config/api_keys.py

@@ -7,10 +7,11 @@ This module provides secure API key storage with best practice warnings.
 
 from __future__ import annotations
 
-import os
 import threading
 import warnings
 
+from traigent.config.provider_support import resolve_api_key_from_env
+
 
 class APIKeyManager:
     """Manages API keys with security best practices."""
@@ -57,28 +58,17 @@ class APIKeyManager:
         Returns:
             The API key if found, None otherwise
         """
-        # Priority: Environment > Explicitly set > Config file
-        env_names = {
-            "openai": "OPENAI_API_KEY",
-            "anthropic": "ANTHROPIC_API_KEY",
-            "cohere": "COHERE_API_KEY",
-            # HuggingFace: native HF_TOKEN first; HF_API_KEY kept for back-compat
-            "huggingface": "HF_TOKEN",
-        }
-
-        # Check environment first (most secure)
-        if provider in env_names:
-            if provider == "huggingface":
-                # Native-first alias chain: HF_TOKEN -> HUGGING_FACE_HUB_TOKEN -> HF_API_KEY
-                env_key = (
-                    os.getenv("HF_TOKEN")
-                    or os.getenv("HUGGING_FACE_HUB_TOKEN")
-                    or os.getenv("HF_API_KEY")
-                )
-            else:
-                env_key = os.getenv(env_names[provider])
-            if env_key:
-                return env_key
+        # Priority: Environment > Explicitly set > Config file.
+        # The env-var chain per provider is derived from the canonical
+        # provider-support table (traigent/config/provider_support.py) so the
+        # key map can no longer drift from the validator's env reading. This is
+        # what gives google (GOOGLE_API_KEY/GEMINI_API_KEY) and mistral
+        # (MISTRAL_API_KEY) first-class key-manager support (#1568) and keeps
+        # the HuggingFace alias chain HF_TOKEN -> HUGGING_FACE_HUB_TOKEN ->
+        # HF_API_KEY intact.
+        env_key = resolve_api_key_from_env(provider)
+        if env_key:
+            return env_key
 
         # Return explicitly set key
         with self._lock: