"""Adapter that runs Prime Intellect ``verifiers`` / Environments Hub envs on Flash. Wraps a ``verifiers`` ``Environment`` (``SingleTurnEnv``, ``MultiTurnEnv``, ``ToolEnv`` and its subclasses) in Flash's small ``Environment`` protocol so Hub environments run unchanged on Flash's trainer. GRPO supports all three shapes (the worker routes on ``multi_turn`` / ``is_tool_env``): * single-turn — TRL's single-shot generation + per-completion reward; * tool (``ToolEnv`` / ``StatefulToolEnv`` / ``SandboxEnv`` / ``PythonEnv``) — TRL drives the tool-call loop natively via ``GRPOTrainer(tools=...)`` (:meth:`tools`), masking tool tokens itself; the reward scores the full transcript (:meth:`reward_from_messages`); * pure multi-turn — ``flash.engine.multiturn_rollout`` supplies a ``rollout_func`` that drives this env's turn loop on the colocate engine via the adapter rollout helpers (:meth:`new_rollout_state` / :meth:`record_model_turn` / :meth:`env_reply` / :meth:`rollout_done`) and returns an ``env_mask`` so only model tokens are trained. Caveats: * SFT on a multi-turn/tool env only fits the single assistant ``sft_target`` per row and ignores tool/env turns, so it should be avoided (see ``run_sft`` / ``sft_target``); * a ``StatefulToolEnv`` whose tools need verifiers' state-injection (``update_tool_args``) is only fully honored on the rollout path — under TRL's native tool loop the tools are called as plain functions. verifiers contract (docs): * ``vf.load_environment(env_id, **kwargs) -> Environment`` * rows have ``prompt`` (chat messages) + ``answer`` (+ optional ``info``) * ``env.dataset`` / ``env.get_dataset(n, seed)``, ``env.eval_dataset`` / ``get_eval_dataset`` * ``env.system_prompt``, ``env.parser``, ``env.rubric`` (weighted reward funcs that take ``completion``/``prompt``/``answer``/``info``/``state``/``parser``/``judge`` by name; sync or async) * multi-turn: ``env.env_response(messages, state)`` -> env reply messages; ``env.is_completed(state)`` -> done flag (both async) Hub conveniences handled here so the *documented* flow (``slm env install owner/name`` + ``[environment] id = "owner/name"``) works on real Prime Intellect envs: * the ``owner/name`` Hub slug is mapped to the bare ``verifiers`` load id; * a ``RubricGroup`` (rubrics-of-rubrics) is flattened so the real reward funcs are found; eval-metric monitor funcs still run (for shared-state side effects / logging) with their exceptions guarded, but contribute 0 — only weighted funcs count toward the reward; * a ``JudgeRubric``'s judge client/model/prompt is supplied to reward funcs that declare a ``judge``/``judge_client``/``judge_model``/``judge_prompt`` arg, so judge-based rewards run; * named per-scorer breakdowns (``scores_breakdown``) expose each reward func's weighted score so the frontend per-scorer view + W&B series survive; * an optional separate **eval** Hub env (``eval_env_id``) + a fixed eval subset (``eval_examples`` / ``eval_seed``) let you train on one env and evaluate on another. """ from __future__ import annotations import asyncio import contextlib import inspect import json import random from .base import BaseEnvironment # The judge-related kwarg names a reward func may declare, sourced from a JudgeRubric. # Single source of truth for both ``_judge_kwargs`` and ``_AVAILABLE_REWARD_KWARGS``. _JUDGE_KWARG_NAMES = ("judge", "judge_client", "judge_model", "judge_prompt") # The kwargs this adapter can supply to a reward func. The non-judge keys are exactly the # ones built into the ``available`` dict in VerifiersEnvironment._reward_available; the judge # keys come from ``_judge_kwargs``. Deriving the frozenset from these shared names avoids the # manual "keep in sync" coupling (adding a kwarg below without updating the set would # re-trigger the false "requires unavailable arg" failure). _BASE_REWARD_KWARG_NAMES = ( "completion", "prompt", "answer", "info", "state", "parser", "task", ) _AVAILABLE_REWARD_KWARGS = frozenset(_BASE_REWARD_KWARG_NAMES + _JUDGE_KWARG_NAMES) def _reward_requires_unavailable_args(func) -> str | None: """Name of a required arg this adapter cannot supply, or None. Group/batch reward funcs declare plural required params (``completions``, ``prompts``, ``answers``, ...). The worker scores one completion at a time and has no batch, so such a func would be called without its required argument and silently score 0.0 — train/eval on an all-zero signal. Detect it so the caller can fail fast.""" try: params = inspect.signature(func).parameters.values() except (TypeError, ValueError): return None # builtins/uninspectable: _invoke_reward passes everything for p in params: if p.kind in (p.VAR_KEYWORD, p.VAR_POSITIONAL): continue if p.default is inspect.Parameter.empty and p.name not in _AVAILABLE_REWARD_KWARGS: return p.name return None def vf_load_id(env_ref: str) -> str: """Map a Hub slug (``owner/name``) to the bare ``verifiers`` load id (``name``).""" return env_ref.split("/", 1)[1] if "/" in env_ref else env_ref # Flash-reserved keys that may historically have ridden in [environment.params] but are # NOT verifiers ``load_environment`` kwargs. They are handled by the worker/adapter directly # (eval_* via named params; GRPO recipe knobs now live in [train]/TrainSpec). A stray one must # be dropped before forwarding to ``vf.load_environment`` — passing it through would raise a # TypeError in the env's loader (or silently change its behavior). The eval_* keys are also # listed here so the catch-all guard never forwards them even if they reach **kwargs. _RESERVED_ENV_PARAM_KEYS = frozenset( { "eval_env_id", "eval_examples", "eval_seed", "grpo_config", "sft_config", "mode", "records", "eval_records", "reward_command", } ) def _drop_reserved_kwargs(kwargs: dict) -> dict: """Strip Flash-reserved keys so only true verifiers-env kwargs are forwarded.""" dropped = [k for k in kwargs if k in _RESERVED_ENV_PARAM_KEYS] if dropped: print( "[verifiers-adapter] dropping Flash-reserved [environment.params] keys not " f"accepted by vf.load_environment: {', '.join(sorted(dropped))}" ) return {k: v for k, v in kwargs.items() if k not in _RESERVED_ENV_PARAM_KEYS} def _run_async(coro): """Run an awaitable to completion from sync code, even inside a running loop.""" try: asyncio.get_running_loop() except RuntimeError: return asyncio.run(coro) # Already inside a loop (rare for the worker): run in a fresh loop on a thread. import concurrent.futures with concurrent.futures.ThreadPoolExecutor(max_workers=1) as ex: return ex.submit(lambda: asyncio.run(coro)).result() def _call_dataset_getter(obj, method_name: str, *, seed: int, n: int = -1): """Call a verifiers dataset getter, binding (n, seed) when it declares them. verifiers exposes get_dataset/get_eval_dataset as get_X(n=-1, seed=0); some Hub envs declare them WITHOUT defaults, so a no-arg call raised TypeError, swallowed into an empty dataset (a paid run over no data). Bind ``n`` (default -1 = all rows — the adapter does its own fixed subset selection; callers pass a positive cap to avoid materializing a huge split) and the seed when the signature declares them; a genuine failure propagates (fail loudly) instead of silently emptying the split.""" fn = getattr(obj, method_name, None) if not callable(fn): return None try: param_names = set(inspect.signature(fn).parameters) except (TypeError, ValueError): param_names = set() kwargs = {} if "n" in param_names: kwargs["n"] = n if "seed" in param_names: kwargs["seed"] = seed return fn(**kwargs) def _rows_to_list(ds) -> list[dict]: if ds is None: return [] try: return [dict(r) for r in ds] except Exception: return list(ds) def _flatten_rubric(rubric) -> list[tuple]: """Collect ``(func, weight)`` pairs from a rubric, recursing into ``RubricGroup``. verifiers composes rubrics (e.g. a ``RubricGroup`` wrapping a ``MathRubric`` plus a ``MultiTurnMonitorRubric``); the real reward funcs live on the *nested* rubrics while the group's own ``funcs`` is empty. Flattening finds them all. """ funcs = list(getattr(rubric, "funcs", None) or getattr(rubric, "reward_funcs", None) or []) weights = list( getattr(rubric, "weights", None) or getattr(rubric, "reward_weights", None) or [] ) if len(weights) < len(funcs): weights += [1.0] * (len(funcs) - len(weights)) pairs = list(zip(funcs, weights, strict=False)) for sub in getattr(rubric, "rubrics", None) or []: pairs.extend(_flatten_rubric(sub)) return pairs def _find_judge_rubric(rubric): """Return the first ``JudgeRubric`` in a rubric tree (or None), for judge-arg injection.""" if rubric is None: return None try: import verifiers as vf judge_cls = getattr(vf, "JudgeRubric", None) except ImportError: judge_cls = None if judge_cls is not None and isinstance(rubric, judge_cls): return rubric # Duck-type fallback: anything exposing a `judge` method + a judge_client attr. if callable(getattr(rubric, "judge", None)) and hasattr(rubric, "judge_client"): return rubric for sub in getattr(rubric, "rubrics", None) or []: found = _find_judge_rubric(sub) if found is not None: return found return None def _judge_kwargs(judge_rubric) -> dict: """The judge-related kwargs a reward func may declare, sourced from a JudgeRubric.""" if judge_rubric is None: return {} return {name: getattr(judge_rubric, name, None) for name in _JUDGE_KWARG_NAMES} def _invoke_reward(func, available: dict) -> float: """Call a verifiers reward func passing only the kwargs it declares; await if async. Exceptions PROPAGATE. ``scores_breakdown`` invokes this for *weighted* reward funcs, so an exception here is a real (weighted) reward func genuinely failing (e.g. a JudgeRubric judge raising on an API/rate-limit error, or a parse error on row data). Swallowing it as 0.0 would silently train/score on an all-zero signal and waste a paid run, so we fail loudly instead. Eval-metric (optional/monitor) funcs are run through ``_run_eval_metric``, which swallows their exceptions — they contribute 0 either way and may exist only for their side effects (mutating shared ``state`` / logging), so a thrown monitor must not fail a run. """ try: params = inspect.signature(func).parameters if any(p.kind == p.VAR_KEYWORD for p in params.values()): kwargs = dict(available) else: kwargs = {k: v for k, v in available.items() if k in params} except (TypeError, ValueError): kwargs = dict(available) result = func(**kwargs) if inspect.isawaitable(result): result = _run_async(result) return float(result or 0.0) def _run_eval_metric(func, available: dict) -> None: """Run a eval-metric monitor/diagnostic reward func, swallowing any exception. Per verifiers semantics every reward func RUNS, even weight-0 ones: they may mutate the shared ``state`` (so a later weighted func sees their work) or simply be logged. They never contribute to the reward (weight is 0), so their result is discarded and a failure must NOT fail the run — guard the exception. Weighted funcs go through ``_invoke_reward`` instead, where exceptions propagate. """ with contextlib.suppress(Exception): _invoke_reward(func, available) def _is_multi_turn(vf_env) -> bool: """True for a tool/multi-turn verifiers env (NOT a plain SingleTurnEnv).""" try: import verifiers as vf except ImportError: return False tool = getattr(vf, "ToolEnv", None) multi = getattr(vf, "MultiTurnEnv", None) single = getattr(vf, "SingleTurnEnv", None) if tool is not None and isinstance(vf_env, tool): return True if multi is not None and isinstance(vf_env, multi): # SingleTurnEnv subclasses MultiTurnEnv in verifiers; exempt it. return not (single is not None and isinstance(vf_env, single)) return False def _is_tool_env(vf_env) -> bool: """True for a verifiers ``ToolEnv`` or any subclass (Stateful/Sandbox/Python). Tool envs expose Python tool callables; the worker hands those to TRL's ``GRPOTrainer(tools=...)`` so TRL drives the tool-call loop natively (it owns generation, tool execution, and assistant-only token masking). A *pure* ``MultiTurnEnv`` (env turns are arbitrary content, e.g. a simulated user) is multi-turn but NOT a tool env, and takes the ``rollout_func`` path instead.""" try: import verifiers as vf except ImportError: return False tool = getattr(vf, "ToolEnv", None) return tool is not None and isinstance(vf_env, tool) class VerifiersEnvironment(BaseEnvironment): """Flash environment backed by a verifiers ``Environment`` instance. GRPO training supports three env shapes (the worker routes on these flags): * **single-turn** (``multi_turn`` False) — TRL's single-shot rollout (original path); * **tool** (``is_tool_env`` True) — TRL drives the tool-call loop natively via ``GRPOTrainer(tools=...)`` (:meth:`tools`); the reward scores the full transcript (:meth:`reward_from_messages`); * **pure multi-turn** (``multi_turn`` True, ``is_tool_env`` False) — TRL's ``rollout_func`` drives this env's turn loop (:meth:`new_rollout_state` / :meth:`record_model_turn` / :meth:`env_reply` / :meth:`rollout_done`). """ def __init__( self, vf_env, env_id: str, eval_vf_env=None, eval_examples: int | None = None, eval_seed: int = 12345, ): super().__init__(id=env_id) self._env = vf_env self._eval_env = eval_vf_env # optional separate eval Hub env self._eval_examples = int(eval_examples) if eval_examples else 0 self._eval_seed = int(eval_seed) self.multi_turn = _is_multi_turn(vf_env) self.is_tool_env = _is_tool_env(vf_env) # Turn cap for the tool / multi-turn rollout loop (verifiers ToolEnv defaults to 10). self.max_turns = int(getattr(vf_env, "max_turns", 10) or 10) # The shared scorer is the TRAIN env's (flattened) rubric + parser, so the reward used # for RL and the grader used at eval are byte-for-byte identical. rubric = getattr(vf_env, "rubric", None) self._reward_pairs = _flatten_rubric(rubric) if rubric is not None else [] self._judge_rubric = _find_judge_rubric(rubric) # Fail fast on a group/batch reward func: the worker scores one completion at a time # and cannot supply its plural batch args, so it would silently score 0.0 and train a # paid run on an all-zero signal. Only weighted funcs matter (eval-metric ones skip). for func, weight in self._reward_pairs: if not weight: continue missing = _reward_requires_unavailable_args(func) if missing: raise ValueError( f"verifiers reward function {getattr(func, '__name__', func)!r} requires " f"argument {missing!r}, which the Flash adapter cannot supply (it scores " "one completion at a time, with no group/batch context such as " "completions/prompts/answers). This environment uses a group-based reward " "not supported on Flash; use a per-completion reward." ) self._parser = getattr(vf_env, "parser", None) # -- data ------------------------------------------------------------- def dataset(self, split: str, limit: int | None = None) -> list[dict]: is_eval = split in {"eval", "validation", "test"} if is_eval: src = self._eval_env or self._env # ``limit`` caps materialization at the source (mid-run eval only needs a small slice); # a getter that ignores ``n`` still returns everything, so _fixed_subset / the caller's # slice remain the backstop. -1 = all rows (the no-cap default). n = limit if (limit is not None and limit > 0) else -1 # Resolve the eval source with explicit ``is None`` checks (NOT ``or``): an # empty-but-configured eval split (``[]``) is falsy, so ``or`` would wrongly # fall through to the next source and ultimately to the TRAIN split — evaluating # on training data. Only fall back when the eval source is genuinely *absent* # (None), not merely empty. ``get_eval_dataset``/``eval_dataset`` returning [] is # a deliberate empty eval set and must be honored as such. eval_ds = _call_dataset_getter(src, "get_eval_dataset", seed=self._eval_seed, n=n) if eval_ds is None: eval_ds = getattr(src, "eval_dataset", None) if eval_ds is None: # no eval split configured at all: use the env's train split eval_ds = _call_dataset_getter(src, "get_dataset", seed=self._eval_seed, n=n) if eval_ds is None: eval_ds = getattr(src, "dataset", None) rows = _rows_to_list(eval_ds) # An explicit positive ``limit`` means the caller (mid-run eval) wants a RAW pool of up # to ``limit`` rows and does its OWN seeded sampling on top — so don't also apply the # ``[environment.params] eval_examples`` subset here, which would silently shrink the # pool below ``limit`` and starve the caller's sample (it already capped the pool size # via ``limit``). ``_fixed_subset`` still governs the plain ``dataset("eval")`` path # (the "eval on a different env" feature, where the param IS the intended sample size). if limit is not None and limit > 0: return rows return self._fixed_subset(rows) ds = _call_dataset_getter(self._env, "get_dataset", seed=0) if ds is None: ds = getattr(self._env, "dataset", None) return _rows_to_list(ds) def has_eval_split(self) -> bool: """True when a DISTINCT held-out eval split exists (a separate eval env, or the env's ``get_eval_dataset``/``eval_dataset``). False means :meth:`dataset` would fall back to train rows — so a caller (mid-run eval) can warn instead of reporting train data as held-out. Best-effort: a getter that raises is treated as no eval split.""" if self._eval_env is not None: return True try: if ( _call_dataset_getter(self._env, "get_eval_dataset", seed=self._eval_seed) is not None ): return True except Exception: return False return getattr(self._env, "eval_dataset", None) is not None def _fixed_subset(self, rows: list[dict]) -> list[dict]: n = self._eval_examples if n <= 0 or n >= len(rows): return rows idx = sorted(random.Random(self._eval_seed).sample(range(len(rows)), n)) return [rows[i] for i in idx] # -- task interface --------------------------------------------------- def prompt_messages(self, example: dict) -> list[dict]: prompt = example.get("prompt") if isinstance(prompt, list) and prompt: msgs = [dict(m) for m in prompt] else: question = example.get("question") or example.get("prompt") or "" msgs = [{"role": "user", "content": str(question)}] system_prompt = getattr(self._env, "system_prompt", None) if system_prompt and not any(m.get("role") == "system" for m in msgs): msgs = [{"role": "system", "content": system_prompt}, *msgs] return msgs def sft_target(self, example: dict) -> str: for key in ("answer", "completion", "target", "response"): value = example.get(key) if value: if isinstance(value, list): # chat messages return str(value[-1].get("content", "")) return str(value) return "" # -- reward / scoring ------------------------------------------------- def _normalize_info(self, example: dict) -> dict: # Hub rows may store `info` as a JSON string (a supported Verifiers row shape); # parse it so reward funcs that do `info[...]` get a dict, not a str (which would # raise TypeError, be swallowed as 0.0, and poison the signal). info = example.get("info") or {} if isinstance(info, str): try: info = json.loads(info) except (ValueError, TypeError): info = {} return info def _reward_available(self, completion: str, example: dict, state: dict | None) -> dict: # In multi-turn/tool mode the accumulated transcript lives on ``state`` (built by the # rollout helpers): ``state["completion"]`` is the full assistant + tool/env message # list and ``state["prompt"]`` is the initial prompt. Reward/tool funcs that inspect the # whole message list need that transcript, not the scalar ``completion`` string wrapped # as a lone synthesized assistant message. Single-turn falls back to wrapping the scalar. completion_msgs: list[dict] | None = None prompt_msgs = None if self.multi_turn and state: transcript = state.get("completion") if isinstance(transcript, list) and transcript: completion_msgs = [dict(m) for m in transcript] state_prompt = state.get("prompt") if isinstance(state_prompt, list) and state_prompt: prompt_msgs = [dict(m) for m in state_prompt] if completion_msgs is None: completion_msgs = [{"role": "assistant", "content": completion}] if prompt_msgs is None: prompt_msgs = example.get("prompt") or self.prompt_messages(example) available = { "completion": completion_msgs, "prompt": prompt_msgs, "answer": example.get("answer"), "info": self._normalize_info(example), "state": state if state is not None else {}, "parser": self._parser, "task": example, } available.update(_judge_kwargs(self._judge_rubric)) return available def scores_breakdown( self, completion: str, example: dict, state: dict | None = None ) -> dict[str, float]: """Per-scorer weighted scores: ``{func_name: weighted_score, ..., "total": sum}``. Every WEIGHTED rubric func contributes one entry (by ``func.__name__``); the ``"total"`` is their sum (== :meth:`reward`). Used to preserve the frontend per-scorer breakdown + W&B series instead of collapsing to a single binary ``correct``. Per verifiers semantics EVERY reward func runs, including eval-metric ones — they may mutate the shared ``state`` (so a subsequent weighted func sees their work) or exist only to be logged. Eval-metric funcs run with GUARDED exceptions (a thrown monitor must not fail the run) and contribute 0, so they are not added to the breakdown/total; the order is preserved so a eval-metric func can prepare state for a later weighted one. Weighted funcs propagate exceptions (a thrown weighted reward fails the run). """ breakdown: dict[str, float] = {} if not self._reward_pairs: answer = str(example.get("answer") or "") score = 1.0 if answer and answer in (completion or "") else 0.0 return {"answer_match": score, "total": score} available = self._reward_available(completion, example, state) total = 0.0 for func, weight in self._reward_pairs: if not weight: # Eval-metric monitor/diagnostic func: RUN it (for its side effects on shared # state / logging) with guarded exceptions, but it contributes 0 and is not in # the named breakdown. _run_eval_metric(func, available) continue name = getattr(func, "__name__", str(func)) score = float(weight) * _invoke_reward(func, available) # Collisions (two funcs share a name): keep them distinct so neither is lost. # Probe for an unused exact key — a prefix/length heuristic can recompute a # suffix that collides with an already-recorded key (e.g. ``score`` vs # ``score_detail``) and silently overwrite a scorer. if name in breakdown: base = name i = 1 while name in breakdown: name = f"{base}_{i}" i += 1 breakdown[name] = score total += score breakdown["total"] = total return breakdown def reward(self, completion: str, example: dict, state: dict | None = None) -> float: return float(self.scores_breakdown(completion, example, state)["total"]) def evaluate(self, completion: str, example: dict, state: dict | None = None) -> dict: """One pass over the rubric returning the training ``reward`` AND the env's separate ``metrics`` — each EVAL-METRIC rubric func's raw (unweighted) score, by name. Eval-metric funcs are how a verifiers ``environment.py`` expresses an EVALUATION signal distinct from the GRPO reward: an ``exact_match`` / ``accuracy`` monitor added with ``rubric.add_metric(fn, weight=0.0)`` does not shape training (weight 0) but measures quality. :meth:`scores_breakdown`/:meth:`reward` deliberately omit these; mid-run eval wants them, so this method surfaces them WITHOUT a second rubric pass (a ``JudgeRubric`` is sampled at most once). Weighted funcs still propagate exceptions (a broken weighted reward fails the run); eval-metric monitors stay guarded (a thrown monitor is skipped, never fails eval). Order is preserved so a monitor can prep shared ``state`` for a later weighted func, exactly as in :meth:`scores_breakdown`. Returns ``{"reward": , "metrics": {name: raw_score, ...}}``; an env with no rubric falls back to the substring ``answer_match`` as both reward and (empty) metrics. """ if not self._reward_pairs: answer = str(example.get("answer") or "") score = 1.0 if answer and answer in (completion or "") else 0.0 return {"reward": score, "metrics": {}} available = self._reward_available(completion, example, state) total = 0.0 metrics: dict[str, float] = {} for func, weight in self._reward_pairs: name = getattr(func, "__name__", str(func)) if not weight: # Eval-metric = an eval/monitor metric: run it (guarded — a thrown monitor must # not fail eval) and record its RAW score; it never touches the reward total. try: raw = _invoke_reward(func, available) except Exception: continue key = name i = 1 while key in metrics: # keep colliding metric names distinct key = f"{name}_{i}" i += 1 metrics[key] = raw continue total += float(weight) * _invoke_reward(func, available) return {"reward": total, "metrics": metrics} def tools(self) -> list: """The underlying ToolEnv's Python tool callables (``[]`` for non-tool envs). Handed to ``GRPOTrainer(tools=...)`` so TRL runs the tool-call loop and does the assistant-only token masking itself. Each is a plain function with type hints + a Google-style docstring (verifiers and TRL share that requirement).""" return list(getattr(self._env, "tools", None) or []) def reward_from_messages( self, completion_msgs: list[dict], example: dict, prompt_msgs: list[dict] | None = None ) -> float: """Reward for a full transcript (assistant + tool/env messages) via the rubric. The tool / multi-turn training path produces a *message list* rollout rather than a single completion string; this routes it through the same weighted-rubric scoring as :meth:`reward` by handing the transcript to the env's reward funcs as ``state``.""" state: dict = {"completion": [dict(m) for m in completion_msgs]} if prompt_msgs: state["prompt"] = [dict(m) for m in prompt_msgs] return self.reward("", example, state) def grade(self, completion: str, example: dict, state: dict | None = None) -> bool: threshold = getattr(self._env, "pass_threshold", 0.5) return self.reward(completion, example, state) >= threshold # -- multi-turn rollout (driven by the worker) ------------------------ def new_rollout_state(self, example: dict) -> dict: """A fresh per-rollout ``state`` dict, threaded through env_reply/reward. Mirrors the verifiers rollout ``state``: holds the running ``prompt``, the accumulated ``completion`` (assistant + tool/env turns), the ``answer``/``info``, and a ``turn`` counter. Reward funcs that read ``state`` see this dict. """ prompt = self.prompt_messages(example) state = { "prompt": [dict(m) for m in prompt], "completion": [], "answer": example.get("answer"), "info": self._normalize_info(example), "responses": [], "turn": 0, } setup = getattr(self._env, "setup_state", None) if callable(setup): with contextlib.suppress(Exception): state = _run_async(setup(state)) or state return state def env_reply(self, messages: list[dict], state: dict) -> list[dict]: """One environment turn: given the conversation so far (incl. the latest model message), return the env's reply messages (tool results / next user turn) and advance ``state``. Empty list when the env has nothing to add. Single-turn envs return [].""" if not self.multi_turn: return [] fn = getattr(self._env, "env_response", None) if not callable(fn): return [] try: reply = _run_async(fn(messages, state)) except NotImplementedError: # Legitimate "this env has no env turn" signal -> no env reply. return [] except Exception as exc: # Mirror `_invoke_reward`: a genuine bug in the env's `env_response` must # NOT be swallowed. Silently returning [] would collapse every multi-turn # rollout to a single turn and train a paid GRPO run on degenerate # transcripts. The rollout loop (multiturn_rollout.py) calls this directly # with no surrounding swallow, so re-raising propagates and fails the run # fast (and the context is printed first so it never vanishes silently). print(f"[env_reply] env_response failed (turn={state.get('turn', 0)}): {exc!r}") raise if reply is None: return [] if isinstance(reply, dict): reply = [reply] out = [dict(m) for m in reply] state["completion"].extend(out) state["turn"] = int(state.get("turn", 0)) + 1 return out def rollout_done(self, state: dict, max_turns: int | None = None) -> bool: """Whether the multi-turn rollout should stop (env says completed, or turn cap hit).""" if not self.multi_turn: return True if max_turns is not None and int(state.get("turn", 0)) >= int(max_turns): return True fn = getattr(self._env, "is_completed", None) if not callable(fn): return True try: return bool(_run_async(fn(state))) except NotImplementedError: # Env doesn't implement a completion check -> rely on the turn cap only. return True except Exception as exc: # Mirror `_invoke_reward` / `env_reply`: a real bug in `is_completed` must # not be silently treated as "done" (which would truncate every rollout and # train on degenerate transcripts). Print context, then re-raise so the run # fails fast (the rollout loop calls this directly with no surrounding swallow). print(f"[rollout_done] is_completed failed (turn={state.get('turn', 0)}): {exc!r}") raise def record_model_turn(self, state: dict, content: str) -> dict: """Append a model (assistant) turn to ``state`` before calling ``env_reply``.""" msg = {"role": "assistant", "content": content} state["completion"].append(msg) state.setdefault("responses", []).append(content) return msg def _import_vf(): try: import verifiers as vf return vf except ImportError as exc: raise ImportError( "the 'verifiers' package is required to run Prime Hub environments; " "install it (e.g. `uv pip install verifiers`) or run `slm env install `" ) from exc def load_verifiers_environment( env_id: str, eval_env_id: str | None = None, eval_examples: int | None = None, eval_seed: int = 12345, **kwargs, ) -> VerifiersEnvironment: """Load an installed / Hub verifiers environment by id and wrap it for Flash. ``env_id`` may be a Hub slug (``owner/name``); it is mapped to the bare verifiers load id. Pass ``eval_env_id`` to evaluate on a *different* Hub env, with ``eval_examples`` / ``eval_seed`` selecting a fixed eval subset. Remaining ``kwargs`` are forwarded to the train env's ``vf.load_environment``. """ vf = _import_vf() vf_env = vf.load_environment(vf_load_id(env_id), **_drop_reserved_kwargs(kwargs)) eval_ref = eval_env_id eval_vf_env = vf.load_environment(vf_load_id(eval_ref)) if eval_ref else None return VerifiersEnvironment( vf_env, env_id, eval_vf_env=eval_vf_env, eval_examples=eval_examples, eval_seed=eval_seed, )