synth-ai 0.2.10__py3-none-any.whl → 0.2.12__py3-none-any.whl

examples/warming_up_to_rl/run_eval.py

@@ -15,6 +15,7 @@ import json
 import os
 import re
 import tomllib
+from copy import deepcopy
 from collections import Counter
 from pathlib import Path
 from typing import Any
@@ -115,26 +116,34 @@ class TaskAppClient:
         run_id: str,
         env_name: str,
         seed: int,
-        difficulty: str,
+        difficulty: str | None,
         policy_name: str,
         policy_config: dict[str, Any],
         max_turns: int,
+        env_config: dict[str, Any] | None = None,
+        ops: list[str] | None = None,
     ) -> dict[str, Any]:
-        ops: list[str] = []
-        for _ in range(max_turns):
-            ops.extend(["agent", "env"])
+        ops_seq: list[str] = list(ops) if ops is not None else []
+        if not ops_seq:
+            for _ in range(max_turns):
+                ops_seq.extend(["agent", "env"])
+        env_cfg: dict[str, Any] = {}
+        if isinstance(env_config, dict):
+            env_cfg.update(env_config)
+        if difficulty is not None and "difficulty" not in env_cfg:
+            env_cfg["difficulty"] = difficulty
         payload: dict[str, Any] = {
             "run_id": run_id,
             "env": {
                 "env_name": env_name,
-                "config": {"difficulty": difficulty},
+                "config": env_cfg,
                 "seed": seed,
             },
             "policy": {
                 "policy_name": policy_name,
                 "config": policy_config,
             },
-            "ops": ops,
+            "ops": ops_seq,
             "on_done": "terminate",
         }
         # Ensure X-API-Key is included
@@ -415,11 +424,20 @@ async def main() -> None:
                 async with sem:
                     try:
                         run_id = f"eval-{seed}"
-                        # Build policy config from TOML (explicit control; no server-side guessing)
-                        policy_cfg: dict[str, Any] = {
-                            "model": cfg.get("model", MODEL),
-                            "inference_url": inf_url,
-                        }
+                        rollout_cfg_raw = cfg.get("rollout") or {}
+                        rollout_cfg = (
+                            dict(rollout_cfg_raw) if isinstance(rollout_cfg_raw, dict) else {}
+                        )
+                        env_config_raw = rollout_cfg.get("env_config") or {}
+                        env_config = (
+                            deepcopy(env_config_raw) if isinstance(env_config_raw, dict) else {}
+                        )
+                        policy_cfg_raw = rollout_cfg.get("policy_config") or {}
+                        policy_cfg = (
+                            deepcopy(policy_cfg_raw) if isinstance(policy_cfg_raw, dict) else {}
+                        )
+                        policy_cfg.setdefault("model", cfg.get("model", MODEL))
+                        policy_cfg.setdefault("inference_url", inf_url)
                         for k in (
                             "max_tokens",
                             "temperature",
@@ -428,18 +446,56 @@ async def main() -> None:
                             "thinking_budget",
                             "use_tools",
                         ):
-                            if k in cfg and cfg.get(k) is not None:
+                            if k in cfg and cfg.get(k) is not None and k not in policy_cfg:
                                 policy_cfg[k] = cfg.get(k)
 
+                        env_name = str(rollout_cfg.get("env_name") or "crafter")
+                        policy_name = str(
+                            rollout_cfg.get("policy_name") or cfg.get("policy_name") or "crafter"
+                        )
+
+                        max_turns_local = MAX_TURNS
+                        for candidate in (rollout_cfg.get("max_turns"), cfg.get("max_turns")):
+                            if candidate is None:
+                                continue
+                            with contextlib.suppress(Exception):
+                                max_turns_local = int(candidate)
+                                break
+
+                        difficulty_override: str | None = None
+                        if isinstance(env_config, dict):
+                            diff_cfg = env_config.get("difficulty")
+                            if isinstance(diff_cfg, str) and diff_cfg:
+                                difficulty_override = diff_cfg
+                        if difficulty_override is None:
+                            cfg_diff = rollout_cfg.get("difficulty") or cfg.get("difficulty")
+                            if isinstance(cfg_diff, str) and cfg_diff:
+                                difficulty_override = cfg_diff
+                        if difficulty_override is None:
+                            difficulty_override = os.getenv("DIFFICULTY", "easy")
+
                         r = await client.rollout(
                             run_id=run_id,
-                            env_name="crafter",
+                            env_name=env_name,
                             seed=seed,
-                            difficulty=os.getenv("DIFFICULTY", "easy"),
-                            policy_name=cfg.get("policy_name", "crafter"),
+                            difficulty=difficulty_override,
+                            policy_name=policy_name,
                             policy_config=policy_cfg,
-                            max_turns=MAX_TURNS,
+                            max_turns=max_turns_local,
+                            env_config=env_config,
                         )
+                        metrics_block = r.get("metrics") or {}
+                        mean_return = None
+                        if isinstance(metrics_block, dict):
+                            with contextlib.suppress(Exception):
+                                mean_return = float(metrics_block.get("mean_return"))
+                        stepwise_details: dict[str, Any] = {}
+                        if isinstance(metrics_block, dict):
+                            details_block = metrics_block.get("details") or {}
+                            if isinstance(details_block, dict):
+                                step_block = details_block.get("stepwise") or {}
+                                if isinstance(step_block, dict):
+                                    stepwise_details = step_block
                         # Extract achievements count if present
                         ach = []
                         try:
@@ -465,9 +521,22 @@ async def main() -> None:
                                 length = int(trajs[0].get("length") or 0)
                         except Exception:
                             pass
-                        return {"seed": seed, "turns": length, "achievements": ach}
+                        return {
+                            "seed": seed,
+                            "turns": length,
+                            "achievements": ach,
+                            "mean_return": mean_return,
+                            "stepwise": stepwise_details,
+                        }
                     except Exception as e:
-                        return {"seed": seed, "turns": 0, "achievements": [], "error": str(e)}
+                        return {
+                            "seed": seed,
+                            "turns": 0,
+                            "achievements": [],
+                            "mean_return": None,
+                            "stepwise": {},
+                            "error": str(e),
+                        }
 
             results = await asyncio.gather(
                 *[asyncio.create_task(_run(i)) for i in range(1, NUM_EPISODES + 1)],
@@ -483,15 +552,63 @@ async def main() -> None:
                         all_ach[a] += 1
                 except Exception:
                     pass
+            mean_returns: list[float] = []
+            stepwise_reward_sums: list[float] = []
+            stepwise_indicator_sums: list[float] = []
+            stepwise_new_ach_totals: list[float] = []
+            strategies_seen = Counter()
+            for r in results:
+                if not isinstance(r, dict):
+                    continue
+                with contextlib.suppress(Exception):
+                    mean_val = r.get("mean_return")
+                    if mean_val is not None:
+                        mean_returns.append(float(mean_val))
+                stepwise_block = r.get("stepwise")
+                if isinstance(stepwise_block, dict) and stepwise_block:
+                    with contextlib.suppress(Exception):
+                        if stepwise_block.get("reward_sum") is not None:
+                            stepwise_reward_sums.append(float(stepwise_block.get("reward_sum")))
+                    with contextlib.suppress(Exception):
+                        if stepwise_block.get("indicator_sum") is not None:
+                            stepwise_indicator_sums.append(float(stepwise_block.get("indicator_sum")))
+                    with contextlib.suppress(Exception):
+                        if stepwise_block.get("new_achievements_total") is not None:
+                            stepwise_new_ach_totals.append(
+                                float(stepwise_block.get("new_achievements_total"))
+                            )
+                    strategy_name = stepwise_block.get("strategy")
+                    if isinstance(strategy_name, str) and strategy_name:
+                        strategies_seen[strategy_name] += 1
+            aggregate: dict[str, Any] = {
+                "completed": sum(
+                    1 for r in results if isinstance(r, dict) and not r.get("error")
+                ),
+                "total": len(results),
+                "avg_turns": (sum(turns) / len(turns)) if turns else 0.0,
+                "avg_achievements": (sum(counts) / len(counts)) if counts else 0.0,
+                "achievements_freq": dict(all_ach),
+            }
+            if mean_returns:
+                aggregate["avg_mean_return"] = sum(mean_returns) / len(mean_returns)
+            if stepwise_reward_sums:
+                aggregate["avg_stepwise_reward_sum"] = sum(stepwise_reward_sums) / len(
+                    stepwise_reward_sums
+                )
+            if stepwise_indicator_sums:
+                aggregate["avg_stepwise_indicator_sum"] = sum(stepwise_indicator_sums) / len(
+                    stepwise_indicator_sums
+                )
+            if stepwise_new_ach_totals:
+                aggregate["avg_stepwise_new_achievements"] = sum(stepwise_new_ach_totals) / len(
+                    stepwise_new_ach_totals
+                )
+            if strategies_seen:
+                aggregate["stepwise_strategies"] = dict(strategies_seen)
+            aggregate["stepwise_samples"] = len(stepwise_reward_sums)
             summary = {
                 "episodes": results,
-                "aggregate": {
-                    "completed": sum(1 for r in results if not r.get("error")),
-                    "total": len(results),
-                    "avg_turns": (sum(turns) / len(turns)) if turns else 0.0,
-                    "avg_achievements": (sum(counts) / len(counts)) if counts else 0.0,
-                    "achievements_freq": dict(all_ach),
-                },
+                "aggregate": aggregate,
             }
             print(json.dumps(summary, indent=2))
         else:

examples/warming_up_to_rl/task_app/synth_envs_hosted/rollout.py

@@ -9,7 +9,7 @@ from datetime import datetime
 from typing import Any
 
 from fastapi import APIRouter, HTTPException, Request, status
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 from synth_ai.lm.vendors.base import BaseLMResponse
 from synth_ai.task.tracing_utils import unique_sft_path
 from synth_ai.tracing_v3.abstractions import EnvironmentEvent, LMCAISEvent, TimeRecord
@@ -142,12 +142,59 @@ class RolloutTrajectory(BaseModel):
     decision_samples: list[dict[str, Any]] | None = None
 
 
+def _normalize_step_strategy(raw_strategy: Any) -> str:
+    if not isinstance(raw_strategy, str):
+        return "consistent"
+    candidate = raw_strategy.strip().lower()
+    if not candidate:
+        return "consistent"
+    mapping = {
+        "simple": "consistent",
+        "consistent": "consistent",
+        "consistent_stepwise": "consistent",
+        "decision_consistent": "consistent",
+        "per_achievement": "per_achievement",
+        "per-achievement": "per_achievement",
+        "perachievement": "per_achievement",
+        "achievement_weighted": "per_achievement",
+        "complex": "per_achievement",
+    }
+    return mapping.get(candidate, "consistent")
+
+
+def _coerce_weights(raw_weights: Any) -> dict[str, float]:
+    weights: dict[str, float] = {}
+    if isinstance(raw_weights, dict):
+        for key, value in raw_weights.items():
+            try:
+                weights[str(key)] = float(value)
+            except Exception:
+                continue
+    return weights
+
+
+def _coerce_k_limits(raw_limits: Any) -> dict[str, int]:
+    limits: dict[str, int] = {}
+    if isinstance(raw_limits, dict):
+        for key, value in raw_limits.items():
+            try:
+                limits[str(key)] = int(value)
+            except Exception:
+                continue
+    return limits
+
+
 def compute_stepwise_reward(
     prev_achievements: dict[str, bool],
     new_achievements: dict[str, bool],
     decision_index: int,
     actions_summary: list[dict[str, Any]],
     indicator_lambda: float,
+    *,
+    strategy: str | None = None,
+    weights: dict[str, float] | None = None,
+    k_limits: dict[str, int] | None = None,
+    episode_counts: dict[str, int] | None = None,
 ) -> tuple[dict[str, Any], dict[str, Any], dict[str, float]]:
     """Compute stepwise reward metadata given achievement states before/after a decision."""
 
@@ -156,24 +203,88 @@ def compute_stepwise_reward(
 
     unlocked = [name for name, value in next_map.items() if value and not prev_map.get(name, False)]
     indicator = 1 if unlocked else 0
-    reward_value = float(indicator_lambda) * indicator
+    normalized_strategy = _normalize_step_strategy(strategy)
+    base_reward = 0.0
+    reward_components: list[dict[str, Any]] = []
+    credited: list[str] = []
+
+    if indicator:
+        if normalized_strategy == "per_achievement":
+            weight_map = weights or {}
+            limit_map = k_limits or {}
+            counts = episode_counts if isinstance(episode_counts, dict) else {}
+            for name in unlocked:
+                try:
+                    limit_val = int(limit_map.get(name, 1))
+                except Exception:
+                    limit_val = 1
+                # limit_val <= 0 implies unlimited rewards
+                unlimited = limit_val <= 0
+                try:
+                    prev_count = int(counts.get(name, 0))
+                except Exception:
+                    prev_count = 0
+                should_credit = unlimited or (prev_count < max(limit_val, 0))
+                if should_credit:
+                    try:
+                        weight_val = float(weight_map.get(name, 1.0))
+                    except Exception:
+                        weight_val = 1.0
+                    base_reward += weight_val
+                    reward_components.append(
+                        {
+                            "achievement": name,
+                            "weight": weight_val,
+                            "count_prior": prev_count,
+                            "count_limit": limit_val,
+                        }
+                    )
+                    credited.append(name)
+                    if episode_counts is not None:
+                        episode_counts[name] = prev_count + 1
+        else:
+            base_reward = 1.0
+            reward_components.append(
+                {
+                    "achievement": "__indicator__",
+                    "weight": 1.0,
+                    "count_prior": 0,
+                    "count_limit": 1,
+                }
+            )
+
+    reward_value = float(indicator_lambda) * float(base_reward)
 
     stepwise_info = {
         "decision_index": decision_index,
         "indicator": indicator,
         "new_achievements": unlocked,
         "reward": reward_value,
+        "strategy": normalized_strategy,
+        "base_reward": float(base_reward),
     }
+    if reward_components:
+        stepwise_info["components"] = reward_components
+    if credited:
+        stepwise_info["credited_achievements"] = credited
+
     decision_sample = {
         "decision_index": decision_index,
         "indicator": indicator,
         "r_i": reward_value,
+        "base": float(base_reward),
+        "strategy": normalized_strategy,
         "actions": actions_summary,
     }
+    if reward_components:
+        decision_sample["components"] = reward_components
+
     stats = {
         "indicator": float(indicator),
         "reward": reward_value,
         "new_achievements_count": float(len(unlocked)),
+        "base_reward": float(base_reward),
+        "credited_achievements_count": float(len(credited)),
     }
     return stepwise_info, decision_sample, stats
 
@@ -183,6 +294,9 @@ class RolloutMetrics(BaseModel):
     mean_return: float
     num_steps: int
     num_episodes: int = 0
+    outcome_score: float | None = None
+    events_score: float | None = None
+    details: dict[str, Any] = Field(default_factory=dict)
 
 
 class RolloutResponse(BaseModel):
@@ -1053,6 +1167,9 @@ async def execute_rollout(
 
         step_rewards_enabled = bool(step_rewards_cfg_raw.get("enabled", False))
         step_rewards_mode = str(step_rewards_cfg_raw.get("mode") or "off").lower()
+        step_rewards_strategy = _normalize_step_strategy(step_rewards_cfg_raw.get("strategy"))
+        step_rewards_weights = _coerce_weights(step_rewards_cfg_raw.get("weights"))
+        step_rewards_k_limits = _coerce_k_limits(step_rewards_cfg_raw.get("k_limits"))
         try:
             step_rewards_indicator_lambda = float(
                 step_rewards_cfg_raw.get("indicator_lambda") or 0.0
@@ -1113,6 +1230,7 @@ async def execute_rollout(
         episode_seen_achievements: set[str] = {
             k for k, v in (prev_achievements or {}).items() if bool(v)
         }
+        episode_achievement_counts: dict[str, int] = {}
         stepwise_indicator_sum = 0.0
         stepwise_reward_sum = 0.0
         stepwise_new_achievements_total = 0
@@ -1560,6 +1678,10 @@ async def execute_rollout(
                         decision_index,
                         decision_actions,
                         step_rewards_indicator_lambda,
+                        strategy=step_rewards_strategy,
+                        weights=step_rewards_weights,
+                        k_limits=step_rewards_k_limits,
+                        episode_counts=episode_achievement_counts,
                     )
                     indicator_val = int(stats.get("indicator", 0.0))
                     reward_stepwise = float(stats.get("reward", 0.0))
@@ -1656,6 +1778,11 @@ async def execute_rollout(
 
                         reset_response = await reset_environment(EnvResetRequest(env_id=env_id))
                         current_obs = reset_response.observation
+                        prev_achievements = _extract_achievements(current_obs)
+                        episode_seen_achievements = {
+                            k for k, v in (prev_achievements or {}).items() if bool(v)
+                        }
+                        episode_achievement_counts.clear()
                     elif request.on_done == "terminate":
                         break
 
@@ -1704,6 +1831,23 @@ async def execute_rollout(
             num_steps=len(trajectory_steps),
             num_episodes=1,
         )
+        if step_rewards_active:
+            stepwise_summary: dict[str, Any] = {
+                "indicator_sum": float(stepwise_indicator_sum),
+                "reward_sum": float(stepwise_reward_sum),
+                "new_achievements_total": int(stepwise_new_achievements_total),
+                "mode": step_rewards_mode,
+                "strategy": step_rewards_strategy,
+                "indicator_lambda": float(step_rewards_indicator_lambda),
+            }
+            if step_rewards_beta:
+                stepwise_summary["step_beta"] = float(step_rewards_beta)
+            if step_rewards_strategy == "per_achievement":
+                if step_rewards_weights:
+                    stepwise_summary["weights"] = dict(step_rewards_weights)
+                if step_rewards_k_limits:
+                    stepwise_summary["k_limits"] = dict(step_rewards_k_limits)
+            metrics.details["stepwise"] = stepwise_summary
 
         # Environment-specific: Log summary if available
         try:

synth_ai/api/train/builders.py

@@ -1,16 +1,24 @@
 from __future__ import annotations
 
+import importlib
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any
+from typing import Any, cast
 
 import click
-from synth_ai.api.models.supported import (
-    UnsupportedModelError,
-    ensure_allowed_model,
-    normalize_model_identifier,
-)
-from synth_ai.learning.sft.config import prepare_sft_job_payload
+
+try:
+    _models_module = importlib.import_module("synth_ai.api.models.supported")
+    UnsupportedModelError = _models_module.UnsupportedModelError
+    ensure_allowed_model = _models_module.ensure_allowed_model
+    normalize_model_identifier = _models_module.normalize_model_identifier
+except Exception as exc:  # pragma: no cover - critical dependency
+    raise RuntimeError("Unable to load supported model helpers") from exc
+
+try:
+    prepare_sft_job_payload = importlib.import_module("synth_ai.learning.sft.config").prepare_sft_job_payload
+except Exception as exc:  # pragma: no cover - critical dependency
+    raise RuntimeError("Unable to load SFT payload helpers") from exc
 
 from .supported_algos import (
     AlgorithmValidationError,
@@ -122,23 +130,26 @@ def build_rl_payload(
     except Exception:
         pass
 
+    payload_data: dict[str, Any] = {
+        "endpoint_base_url": final_task_url.rstrip("/"),
+        "config": data,
+    }
     payload: dict[str, Any] = {
         "job_type": "rl",
         "compute": data.get("compute", {}),
-        "data": {
-            "endpoint_base_url": final_task_url.rstrip("/"),
-            "config": data,
-        },
+        "data": payload_data,
         "tags": {"source": "train-cli"},
     }
     if model_source:
-        payload["data"]["model"] = model_source
+        payload_data["model"] = model_source
     if model_base:
-        payload["data"]["base_model"] = model_base
+        payload_data["base_model"] = model_base
 
     backend = overrides.get("backend")
     if backend:
-        payload.setdefault("metadata", {})["backend_base_url"] = ensure_api_base(str(backend))
+        metadata_default: dict[str, Any] = {}
+        metadata = cast(dict[str, Any], payload.setdefault("metadata", metadata_default))
+        metadata["backend_base_url"] = ensure_api_base(str(backend))
 
     return RLBuildResult(payload=payload, task_url=final_task_url, idempotency=idempotency)
 

synth_ai/api/train/cli.py

@@ -1,11 +1,18 @@
 from __future__ import annotations
 
+import importlib
 import os
+from collections.abc import Mapping
 from pathlib import Path
 from typing import Any
 
 import click
-from synth_ai.config.base_url import get_backend_from_env
+
+try:
+    _config_module = importlib.import_module("synth_ai.config.base_url")
+    get_backend_from_env = _config_module.get_backend_from_env
+except Exception as exc:  # pragma: no cover - critical dependency
+    raise RuntimeError("Unable to load backend configuration helpers") from exc
 
 from .builders import build_rl_payload, build_sft_payload
 from .config_finder import discover_configs, prompt_for_config
@@ -231,7 +238,8 @@ def train_command(
     ]
     if missing_keys:
         try:
-            from synth_ai.cli.task_apps import _interactive_fill_env
+            _task_apps_module = importlib.import_module("synth_ai.cli.task_apps")
+            _interactive_fill_env = _task_apps_module._interactive_fill_env
         except Exception as exc:  # pragma: no cover - protective fallback
             raise click.ClickException(f"Unable to prompt for env values: {exc}") from exc
 
@@ -386,9 +394,19 @@ def handle_rl(
             verify_url, headers=verify_headers, json_body={"endpoint_base_url": build.task_url}
         )
         try:
-            vjs = vresp.json()
+            parsed_json = vresp.json()
         except Exception:
-            vjs = {"status": vresp.status_code, "text": (vresp.text or "")[:400]}
+            parsed_json = None
+
+        if isinstance(parsed_json, Mapping):
+            vjs: dict[str, Any] = dict(parsed_json)
+        else:
+            vjs = {
+                "status": vresp.status_code,
+                "text": (vresp.text or "")[:400],
+            }
+            if parsed_json is not None:
+                vjs["body"] = parsed_json
     except Exception as _ve:
         raise click.ClickException(
             f"Task app verification call failed: {type(_ve).__name__}: {_ve}"
@@ -404,8 +422,13 @@ def handle_rl(
         # Print concise summary
         try:
             cands = vjs.get("candidates_first15") or []
-            attempts = vjs.get("attempts") or []
-            statuses = [a.get("status") for a in attempts]
+            attempts_raw = vjs.get("attempts")
+            attempts: list[Mapping[str, Any]] = (
+                [a for a in attempts_raw if isinstance(a, Mapping)]
+                if isinstance(attempts_raw, list)
+                else []
+            )
+            statuses = [attempt.get("status") for attempt in attempts]
             click.echo(f"Verification OK (candidates={cands}, statuses={statuses})")
         except Exception:
             pass

synth_ai/api/train/env_resolver.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import importlib
 import os
 from collections.abc import Callable, Iterable, MutableMapping
 from dataclasses import dataclass
@@ -11,6 +12,18 @@ from . import task_app
 from .utils import REPO_ROOT, mask_value, read_env_file, write_env_value
 
 
+def _load_saved_env_path() -> Path | None:
+    try:
+        module = importlib.import_module("synth_ai.demos.demo_task_apps.core")
+        loader = module.load_env_file_path
+        saved_path = loader()
+        if saved_path:
+            return Path(saved_path)
+    except Exception:
+        return None
+    return None
+
+
 @dataclass(slots=True)
 class KeySpec:
     name: str
@@ -156,25 +169,11 @@ def resolve_env(
                 raise click.ClickException(f"Env file not found: {path}")
         resolver = EnvResolver(provided)
     else:
-        # Check for saved .env path from demo command
-        try:
-            from synth_ai.demos.demo_task_apps.core import load_env_file_path
-
-            saved_env_path = load_env_file_path()
-            if saved_env_path:
-                saved_path = Path(saved_env_path)
-                if saved_path.exists():
-                    click.echo(f"Using .env file: {saved_path}")
-                    resolver = EnvResolver([saved_path])
-                else:
-                    # Saved path no longer exists, fall back to prompt
-                    resolver = EnvResolver(_collect_default_candidates(config_path))
-                    resolver.select_new_env()
-            else:
-                resolver = EnvResolver(_collect_default_candidates(config_path))
-                resolver.select_new_env()
-        except Exception:
-            # If import fails or any error, fall back to original behavior
+        saved_path = _load_saved_env_path()
+        if saved_path and saved_path.exists():
+            click.echo(f"Using .env file: {saved_path}")
+            resolver = EnvResolver([saved_path])
+        else:
             resolver = EnvResolver(_collect_default_candidates(config_path))
             resolver.select_new_env()
 

synth_ai/api/train/supported_algos.py

@@ -1,13 +1,16 @@
 from __future__ import annotations
 
+import importlib
 from collections.abc import Mapping
 from dataclasses import dataclass
 
-from synth_ai.api.models.supported import (
-    RL_SUPPORTED_MODELS,
-    SFT_SUPPORTED_MODELS,
-    training_modes_for_model,
-)
+try:
+    _models_module = importlib.import_module("synth_ai.api.models.supported")
+    RL_SUPPORTED_MODELS = _models_module.RL_SUPPORTED_MODELS
+    SFT_SUPPORTED_MODELS = _models_module.SFT_SUPPORTED_MODELS
+    training_modes_for_model = _models_module.training_modes_for_model
+except Exception as exc:  # pragma: no cover - critical dependency
+    raise RuntimeError("Unable to load supported model metadata") from exc
 
 
 @dataclass(frozen=True)