synth-ai 0.2.9.dev5__py3-none-any.whl → 0.2.9.dev7__py3-none-any.whl

examples/warming_up_to_rl/task_app/grpo_crafter.py

@@ -8,7 +8,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Dict, Iterable, List, Sequence
 
-from synth_ai.task.contracts import RolloutRequest, RolloutResponse, TaskInfo
+from synth_ai.task.contracts import RolloutRequest, RolloutResponse, TaskInfo, RolloutMetrics
 from synth_ai.task.datasets import TaskDatasetRegistry, TaskDatasetSpec
 from synth_ai.task.rubrics import load_rubric
 from synth_ai.task.server import ProxyConfig, RubricBundle, TaskAppConfig
@@ -33,15 +33,16 @@ for path in [REPO_ROOT, TASK_APP_ROOT, SYNTH_ENVS_HOSTED_ROOT]:
     if path_str not in sys.path:
         sys.path.insert(0, path_str)
 
+HAS_HOSTED = True
 try:
     import crafter  # type: ignore
     import crafter.constants as C  # type: ignore
-    from synth_ai.environments.examples.crafter_classic.taskset import TRAIT_BOUNDS, world_traits
-    from synth_envs_hosted.branching import router as branching_router
-    from synth_envs_hosted.environment_routes import router as environment_router
-    from synth_envs_hosted.hosted_app import TaskApp as HostedTaskApp
-    from synth_envs_hosted.policy_routes import router as policy_router
-    from synth_envs_hosted.rollout import (
+    from synth_ai.environments.examples.crafter_classic.taskset import TRAIT_BOUNDS
+    from synth_envs_hosted.branching import router as branching_router  # type: ignore
+    from synth_envs_hosted.environment_routes import router as environment_router  # type: ignore
+    from synth_envs_hosted.hosted_app import TaskApp as HostedTaskApp  # type: ignore
+    from synth_envs_hosted.policy_routes import router as policy_router  # type: ignore
+    from synth_envs_hosted.rollout import (  # type: ignore
         RolloutEnvSpec as LegacyRolloutEnvSpec,
         RolloutPolicySpec as LegacyRolloutPolicySpec,
         RolloutRecordConfig as LegacyRolloutRecordConfig,
@@ -54,7 +55,9 @@ except Exception as exc:  # pragma: no cover - import-time validation
     # Provide a more actionable error with the missing module and fix hints
     missing_mod = None
     if isinstance(exc, ModuleNotFoundError):
-        missing_mod = getattr(exc, "name", None) or str(exc).split("'")[1] if "'" in str(exc) else None
+        missing_mod = (
+            getattr(exc, "name", None) or str(exc).split("'")[1] if "'" in str(exc) else None
+        )
     fix_hint = None
     if missing_mod:
         mapping = {
@@ -74,12 +77,16 @@ except Exception as exc:  # pragma: no cover - import-time validation
             f"For Modal: add '{pkg}' to ModalDeploymentConfig.pip_packages in synth_ai/task/apps/grpo_crafter.py.\n"
             f"Locally: pip install {pkg}"
         )
-    detailed = (
-        "grpo_crafter task app requires example dependencies and runtime libs.\n"
-        + (fix_hint + "\n" if fix_hint else "")
-        + f"Original error: {exc}"
-    )
-    raise RuntimeError(detailed) from exc
+    # Allow running without synth_envs_hosted; gate hosted features off
+    if missing_mod == "synth_envs_hosted":
+        HAS_HOSTED = False
+    else:
+        detailed = (
+            "grpo_crafter task app requires example dependencies and runtime libs.\n"
+            + (fix_hint + "\n" if fix_hint else "")
+            + f"Original error: {exc}"
+        )
+        raise RuntimeError(detailed) from exc
 
 
 CRAFTING_RULES_SYSTEM_HINT = (
@@ -130,7 +137,7 @@ class CrafterDataset:
         env = crafter.Env(area=self.area, length=self.length, seed=seed)
         try:
             env.reset()
-            traits = world_traits(env)
+            traits = _compute_world_traits(env)
             player = getattr(env, "_player", None)
             inventory = dict(getattr(player, "inventory", {})) if player else {}
             position = getattr(player, "pos", None)
@@ -151,10 +158,9 @@ class CrafterDataset:
 
     def _difficulty(self, traits: Dict[str, int]) -> str:
         for difficulty, bounds in TRAIT_BOUNDS.items():
-            if (
-                traits.get("trees", 0) >= bounds.get("min_trees", 0)
-                and traits.get("hostiles", 0) <= bounds.get("max_hostiles", 0)
-            ):
+            if traits.get("trees", 0) >= bounds.get("min_trees", 0) and traits.get(
+                "hostiles", 0
+            ) <= bounds.get("max_hostiles", 0):
                 return difficulty
         return "custom"
 
@@ -163,6 +169,35 @@ class CrafterDataset:
         return [self.seed_min, self.seed_max]
 
 
+def _compute_world_traits(env: "crafter.Env", radius: int = 10) -> Dict[str, int]:
+    # Local copy to avoid import-time issues; mirrors synth_ai.environments.examples.crafter_classic.taskset.world_traits
+    from crafter import objects as _objects  # type: ignore
+    import numpy as _np  # type: ignore
+
+    player = getattr(env, "_player", None)
+    if player is None:
+        return {"trees": 0, "cows": 0, "hostiles": 0}
+    pos = _np.array(getattr(player, "pos", [0, 0]))
+    counts = {"trees": 0, "cows": 0, "hostiles": 0}
+    world = getattr(env, "_world", None)
+    objects = getattr(world, "_objects", []) if world is not None else []
+    for obj in objects:
+        if obj is None or obj is player:
+            continue
+        try:
+            if _np.abs(getattr(obj, "pos") - pos).sum() > radius:
+                continue
+        except Exception:
+            continue
+        if isinstance(obj, _objects.Plant) and getattr(obj, "kind", "") == "tree":
+            counts["trees"] += 1
+        elif isinstance(obj, _objects.Cow):
+            counts["cows"] += 1
+        elif isinstance(obj, (_objects.Zombie, _objects.Skeleton)):
+            counts["hostiles"] += 1
+    return counts
+
+
 def env_value(key: str, default: Any) -> Any:
     import os
 
@@ -266,7 +301,9 @@ def describe_taskset(dataset: CrafterDataset) -> Dict[str, Any]:
     }
 
 
-def provide_task_instances(dataset: CrafterDataset, base_info: TaskInfo, seeds: Sequence[int]) -> Iterable[TaskInfo]:
+def provide_task_instances(
+    dataset: CrafterDataset, base_info: TaskInfo, seeds: Sequence[int]
+) -> Iterable[TaskInfo]:
     infos: list[TaskInfo] = []
     for seed_value in seeds:
         summary = dataset.describe_seed(seed_value)
@@ -315,6 +352,24 @@ def _normalise_op(op_value: Any, index: int) -> str:
 
 
 async def rollout_executor(request: RolloutRequest, fastapi_request) -> RolloutResponse:
+    # If hosted env service code is not bundled, return a no-op rollout response compatible with contracts
+    if not HAS_HOSTED:
+        return RolloutResponse(
+            run_id=request.run_id,
+            trajectories=[],
+            branches={},
+            metrics=RolloutMetrics(
+                episode_returns=[],
+                mean_return=0.0,
+                num_steps=0,
+                num_episodes=0,
+                details={},
+            ),
+            aborted=False,
+            ops_executed=0,
+            trace=None,
+        )
+
     converted_ops: List[str] = [_normalise_op(op, idx) for idx, op in enumerate(request.ops)]
     legacy_request = LegacyRolloutRequest(
         run_id=request.run_id,
@@ -338,7 +393,9 @@ async def rollout_executor(request: RolloutRequest, fastapi_request) -> RolloutR
         synth_base_url=request.synth_base_url,
     )
 
-    legacy_response: LegacyRolloutResponse = await legacy_execute_rollout(legacy_request, fastapi_request)
+    legacy_response: LegacyRolloutResponse = await legacy_execute_rollout(
+        legacy_request, fastapi_request
+    )
     data = legacy_response.model_dump()
     metrics = data.get("metrics", {}) or {}
     metrics.setdefault("outcome_score", None)
@@ -352,11 +409,13 @@ def build_config() -> TaskAppConfig:
     registry, dataset = build_dataset()
     base_info = _base_task_info(dataset)
 
-    hosted_task_app = HostedTaskApp()
+    hosted_task_app = HostedTaskApp() if HAS_HOSTED else None
 
     tracing_enabled = tracing_env_enabled()
     tracing_db_url = resolve_tracing_db_url()
-    tracer_factory = build_tracer_factory(SessionTracer, enabled=tracing_enabled, db_url=tracing_db_url)
+    tracer_factory = build_tracer_factory(
+        SessionTracer, enabled=tracing_enabled, db_url=tracing_db_url
+    )
     sft_output_dir = resolve_sft_output_dir()
 
     app_state: Dict[str, Any] = {
@@ -383,6 +442,8 @@ def build_config() -> TaskAppConfig:
     def _provide_instances(seeds: Sequence[int]):
         return provide_task_instances(dataset, base_info, seeds)
 
+    routers: tuple = (environment_router, policy_router, branching_router) if HAS_HOSTED else ()
+
     config = TaskAppConfig(
         app_id="grpo-crafter",
         name="GRPO Crafter Task App",
@@ -393,8 +454,10 @@ def build_config() -> TaskAppConfig:
         rollout=rollout_executor,
         dataset_registry=registry,
         rubrics=RubricBundle(outcome=OUTCOME_RUBRIC, events=EVENTS_RUBRIC),
-        proxy=ProxyConfig(enable_openai=True, enable_groq=True, system_hint=CRAFTING_RULES_SYSTEM_HINT),
-        routers=(environment_router, policy_router, branching_router),
+        proxy=ProxyConfig(
+            enable_openai=True, enable_groq=True, system_hint=CRAFTING_RULES_SYSTEM_HINT
+        ),
+        routers=routers,
         app_state=app_state,
         cors_origins=["*"],
     )
@@ -426,8 +489,8 @@ register_task_app(
                 "crafter",
             ),
             extra_local_dirs=(
-                (str(REPO_ROOT / 'synth_ai'), '/opt/synth_ai_repo/synth_ai'),
-                (str(TASK_APP_ROOT), '/opt/synth_ai_repo/examples/warming_up_to_rl/task_app'),
+                (str(REPO_ROOT / "synth_ai"), "/opt/synth_ai_repo/synth_ai"),
+                (str(TASK_APP_ROOT), "/opt/synth_ai_repo/examples/warming_up_to_rl/task_app"),
             ),
             secret_names=("crafter-environment-sdk", "groq-api-key", "openai-api-key"),
             memory=16384,

examples/warming_up_to_rl/task_app/grpo_crafter_task_app.py

@@ -1,9 +1,8 @@
-
 """Compatibility wrapper for the GRPO Crafter task app.
 
-This module now delegates to the shared TaskAppConfig defined in
-`synth_ai.task.apps.grpo_crafter`. It is kept for legacy usage (running the
-file directly or targeting `fastapi_app` from external tooling). Prefer using
+This module now delegates to the TaskAppConfig defined in the colocated example at
+`examples/warming_up_to_rl/task_app/grpo_crafter.py`. It is kept for legacy usage
+(running the file directly or targeting `fastapi_app` from external tooling). Prefer using
 `uvx synth-ai serve grpo-crafter` for local development and testing.
 """
 
@@ -25,27 +24,10 @@ from synth_ai.task.server import TaskAppConfig, create_task_app, run_task_app
 APP_ID = "grpo-crafter"
 
 
-_BASE_CONFIG = build_config()
-TASK_APP_CONFIG = TaskAppConfig(
-    app_id="grpo-crafter",
-    name=_BASE_CONFIG.name,
-    description=_BASE_CONFIG.description,
-    base_task_info=_BASE_CONFIG.base_task_info,
-    describe_taskset=_BASE_CONFIG.describe_taskset,
-    provide_task_instances=_BASE_CONFIG.provide_task_instances,
-    rollout=_BASE_CONFIG.rollout,
-    dataset_registry=_BASE_CONFIG.dataset_registry,
-    rubrics=_BASE_CONFIG.rubrics,
-    proxy=_BASE_CONFIG.proxy,
-    routers=_BASE_CONFIG.routers,
-    middleware=_BASE_CONFIG.middleware,
-    app_state=_BASE_CONFIG.app_state,
-    require_api_key=_BASE_CONFIG.require_api_key,
-    expose_debug_env=_BASE_CONFIG.expose_debug_env,
-    cors_origins=_BASE_CONFIG.cors_origins,
-    startup_hooks=_BASE_CONFIG.startup_hooks,
-    shutdown_hooks=_BASE_CONFIG.shutdown_hooks,
-)
+def _build_base_config() -> TaskAppConfig:
+    # Lazily construct the base config to avoid heavy work at import time
+    return build_config()
+
 
 try:
     _REGISTERED_ENTRY = registry.get(APP_ID)
@@ -59,8 +41,8 @@ else:
 
 def build_task_app_config() -> TaskAppConfig:
     """Return a fresh TaskAppConfig for this wrapper."""
-
-    return TASK_APP_CONFIG.clone()
+    base = _build_base_config()
+    return base.clone()
 
 
 def fastapi_app():

examples/warming_up_to_rl/task_app/synth_envs_hosted/environment_routes.py

@@ -58,9 +58,7 @@ async def validate_environment_observation(observation: Any, context: str) -> No
         "terminated",
     }
     if wordle_keys.issubset(set(observation.keys())):
-        logger.info(
-            f"🔍 ENV_ROUTES: Validating Wordle observation structure in {context}"
-        )
+        logger.info(f"🔍 ENV_ROUTES: Validating Wordle observation structure in {context}")
         logger.info(f"🔍 ENV_ROUTES: Observation keys: {list(observation.keys())}")
 
         missing_keys = wordle_keys - set(observation.keys())
@@ -278,9 +276,7 @@ async def create_environment(request: EnvCreateRequest) -> EnvCreateResponse:
                     WordleEnvironment,
                 )
             except Exception as e:
-                raise HTTPException(
-                    status_code=500, detail=f"Wordle modules unavailable: {e}"
-                )
+                raise HTTPException(status_code=500, detail=f"Wordle modules unavailable: {e}")
 
             # Lazy import of wrapper within branch
             try:
@@ -288,9 +284,7 @@ async def create_environment(request: EnvCreateRequest) -> EnvCreateResponse:
                     WordleEnvironmentWrapper as _WordleWrapper,
                 )
             except Exception as e:
-                raise HTTPException(
-                    status_code=500, detail=f"Wordle wrapper unavailable: {e}"
-                )
+                raise HTTPException(status_code=500, detail=f"Wordle wrapper unavailable: {e}")
 
             cfg = request.config or {}
             word_length = int(cfg.get("word_length", 5))
@@ -307,12 +301,8 @@ async def create_environment(request: EnvCreateRequest) -> EnvCreateResponse:
             )
             instance = WordleTaskInstance(
                 id=uuid4(),
-                impetus=Impetus(
-                    instructions="Play Wordle. Submit one 5-letter word per turn."
-                ),
-                intent=Intent(
-                    rubric="guess the word", gold_trajectories=None, gold_state_diff={}
-                ),
+                impetus=Impetus(instructions="Play Wordle. Submit one 5-letter word per turn."),
+                intent=Intent(rubric="guess the word", gold_trajectories=None, gold_state_diff={}),
                 metadata=md,
                 is_reproducible=True,
                 initial_engine_snapshot=None,
@@ -345,9 +335,7 @@ async def create_environment(request: EnvCreateRequest) -> EnvCreateResponse:
                     if key in observation_for_registry:
                         del observation_for_registry[key]
 
-            await validate_environment_observation(
-                observation_for_registry, "initialize"
-            )
+            await validate_environment_observation(observation_for_registry, "initialize")
 
             env_id = registry.register_env(
                 env=wrapper,
@@ -376,9 +364,7 @@ async def create_environment(request: EnvCreateRequest) -> EnvCreateResponse:
                     SokobanEnvironment,
                 )
             except Exception as e:
-                raise HTTPException(
-                    status_code=500, detail=f"Sokoban modules unavailable: {e}"
-                )
+                raise HTTPException(status_code=500, detail=f"Sokoban modules unavailable: {e}")
 
             # Lazy import of wrapper within branch
             try:
@@ -386,9 +372,7 @@ async def create_environment(request: EnvCreateRequest) -> EnvCreateResponse:
                     SokobanEnvironmentWrapper as _SokobanWrapper,
                 )
             except Exception as e:
-                raise HTTPException(
-                    status_code=500, detail=f"Sokoban wrapper unavailable: {e}"
-                )
+                raise HTTPException(status_code=500, detail=f"Sokoban wrapper unavailable: {e}")
 
             cfg = request.config or {}
             difficulty = cfg.get("difficulty", "easy")
@@ -411,9 +395,7 @@ async def create_environment(request: EnvCreateRequest) -> EnvCreateResponse:
             )
             base_env = SokobanEnvironment(task_instance=instance)
 
-            wrapper = _SokobanWrapper(
-                env=base_env, seed=request.seed, config=cfg
-            )
+            wrapper = _SokobanWrapper(env=base_env, seed=request.seed, config=cfg)
             result = await wrapper.initialize()
 
             # Handle the observation structure consistently for Sokoban
@@ -453,9 +435,7 @@ async def create_environment(request: EnvCreateRequest) -> EnvCreateResponse:
                     MathEnvironmentWrapper as _MathWrapper,
                 )
             except Exception as e:
-                raise HTTPException(
-                    status_code=500, detail=f"Math wrapper unavailable: {e}"
-                )
+                raise HTTPException(status_code=500, detail=f"Math wrapper unavailable: {e}")
 
             wrapper = _MathWrapper(
                 seed=request.seed,
@@ -464,7 +444,11 @@ async def create_environment(request: EnvCreateRequest) -> EnvCreateResponse:
             )
             result = await wrapper.initialize()
 
-            observation_for_registry = result["observation"].copy() if isinstance(result, dict) and "observation" in result else result.copy()
+            observation_for_registry = (
+                result["observation"].copy()
+                if isinstance(result, dict) and "observation" in result
+                else result.copy()
+            )
             for key in ["step_idx", "info"]:
                 if key in observation_for_registry:
                     del observation_for_registry[key]
@@ -509,7 +493,9 @@ async def compat_initialize(payload: dict) -> EnvCreateResponse:
         difficulty = str(wc.get("difficulty"))
     elif isinstance(cfg, dict) and cfg.get("difficulty"):
         difficulty = str(cfg.get("difficulty"))
-    req = EnvCreateRequest(env_name="crafter", config={"difficulty": difficulty}, seed=seed, rl_run_id="eval")
+    req = EnvCreateRequest(
+        env_name="crafter", config={"difficulty": difficulty}, seed=seed, rl_run_id="eval"
+    )
     return await create_environment(req)
 
 
@@ -525,10 +511,12 @@ async def compat_step(payload: dict) -> EnvStepResponse:
         actions_list = action.get("actions") if isinstance(action, dict) else None
         if isinstance(actions_list, list) and actions_list:
             for a in actions_list:
-                tool_calls.append({
-                    "tool": "interact",
-                    "args": {"action": a},
-                })
+                tool_calls.append(
+                    {
+                        "tool": "interact",
+                        "args": {"action": a},
+                    }
+                )
     req = EnvStepRequest(env_id=env_id, tool_calls=tool_calls)
     return await step_environment(req)
 
@@ -545,9 +533,7 @@ async def reset_environment(request: EnvResetRequest) -> EnvResetResponse:
     """Reset an environment to its initial state."""
     handle = registry.get_env(request.env_id)
     if not handle:
-        raise HTTPException(
-            status_code=404, detail=f"Environment {request.env_id} not found"
-        )
+        raise HTTPException(status_code=404, detail=f"Environment {request.env_id} not found")
 
     try:
         # Determine wrapper type and rebuild base env if a new seed is provided
@@ -606,9 +592,7 @@ async def reset_environment(request: EnvResetRequest) -> EnvResetResponse:
                         WordleEnvironment,
                     )
                 except Exception as e:
-                    raise HTTPException(
-                        status_code=500, detail=f"Wordle modules unavailable: {e}"
-                    )
+                    raise HTTPException(status_code=500, detail=f"Wordle modules unavailable: {e}")
 
                 init_snap = getattr(wrapper, "initial_engine_snapshot", None)
                 if init_snap is not None:
@@ -655,9 +639,7 @@ async def reset_environment(request: EnvResetRequest) -> EnvResetResponse:
                     WordleEnvironment,
                 )
             except Exception as e:
-                raise HTTPException(
-                    status_code=500, detail=f"Wordle modules unavailable: {e}"
-                )
+                raise HTTPException(status_code=500, detail=f"Wordle modules unavailable: {e}")
 
             init_snap = getattr(wrapper, "initial_engine_snapshot", None)
             if init_snap is not None:
@@ -711,9 +693,7 @@ async def reset_environment(request: EnvResetRequest) -> EnvResetResponse:
                         SokobanEnvironment,
                     )
                 except Exception as e:
-                    raise HTTPException(
-                        status_code=500, detail=f"Sokoban modules unavailable: {e}"
-                    )
+                    raise HTTPException(status_code=500, detail=f"Sokoban modules unavailable: {e}")
 
                 cfg = dict(wrapper.config or {})
                 metadata = SokobanTaskInstanceMetadata(
@@ -746,9 +726,7 @@ async def reset_environment(request: EnvResetRequest) -> EnvResetResponse:
                     SokobanEnvironment,
                 )
             except Exception as e:
-                raise HTTPException(
-                    status_code=500, detail=f"Sokoban modules unavailable: {e}"
-                )
+                raise HTTPException(status_code=500, detail=f"Sokoban modules unavailable: {e}")
 
             cfg = dict(wrapper.config or {})
             metadata = SokobanTaskInstanceMetadata(
@@ -757,9 +735,7 @@ async def reset_environment(request: EnvResetRequest) -> EnvResetResponse:
             instance = SokobanTaskInstance(
                 id=uuid4(),
                 impetus=Impetus(instructions="Reset"),
-                intent=Intent(
-                    rubric={"goal": "Reset"}, gold_trajectories=None, gold_state_diff={}
-                ),
+                intent=Intent(rubric={"goal": "Reset"}, gold_trajectories=None, gold_state_diff={}),
                 metadata=metadata,
                 is_reproducible=True,
                 initial_engine_snapshot=cfg.get("initial_state"),
@@ -818,9 +794,7 @@ async def step_environment(request: EnvStepRequest) -> EnvStepResponse:
     """Execute a step in the environment."""
     handle = registry.get_env(request.env_id)
     if not handle:
-        raise HTTPException(
-            status_code=404, detail=f"Environment {request.env_id} not found"
-        )
+        raise HTTPException(status_code=404, detail=f"Environment {request.env_id} not found")
 
     try:
         # Execute the step, pre-normalizing invalid Wordle guesses to avoid hard failures
@@ -836,12 +810,7 @@ async def step_environment(request: EnvStepRequest) -> EnvStepResponse:
             expected_len = int(getattr(wrapper, "word_length", 5))
             normalized: List[Dict[str, Any]] = []
             for tc in request.tool_calls or []:
-                tool = (
-                    tc.get("tool")
-                    or tc.get("tool_name")
-                    or tc.get("name")
-                    or "interact"
-                )
+                tool = tc.get("tool") or tc.get("tool_name") or tc.get("name") or "interact"
                 args = tc.get("arguments") or tc.get("args") or {}
                 if isinstance(args, str):
                     try:
@@ -861,9 +830,7 @@ async def step_environment(request: EnvStepRequest) -> EnvStepResponse:
                         # Preserve the original tool name (interact or submit) for the environment to handle
                         normalized.append({"tool": tool, "args": {"guess": g}})
                 else:
-                    normalized.append(
-                        {"tool": "invalid_guess", "args": {"original_guess": guess}}
-                    )
+                    normalized.append({"tool": "invalid_guess", "args": {"original_guess": guess}})
             result = await wrapper.step(normalized)
         else:
             result = await handle.env.step(request.tool_calls)
@@ -922,12 +889,7 @@ async def step_environment(request: EnvStepRequest) -> EnvStepResponse:
                 expected_len = int(getattr(wrapper, "word_length", 5))
                 normalized: List[Dict[str, Any]] = []
                 for tc in request.tool_calls or []:
-                    tool = (
-                        tc.get("tool")
-                        or tc.get("tool_name")
-                        or tc.get("name")
-                        or "interact"
-                    )
+                    tool = tc.get("tool") or tc.get("tool_name") or tc.get("name") or "interact"
                     args = tc.get("arguments") or tc.get("args") or {}
                     if isinstance(args, str):
                         try:
@@ -947,9 +909,7 @@ async def step_environment(request: EnvStepRequest) -> EnvStepResponse:
                                 }
                             )
                         else:
-                            normalized.append(
-                                {"tool": "interact", "args": {"guess": g}}
-                            )
+                            normalized.append({"tool": "interact", "args": {"guess": g}})
                     else:
                         normalized.append(
                             {"tool": "invalid_guess", "args": {"original_guess": guess}}
@@ -989,9 +949,7 @@ async def snapshot_environment(request: EnvSnapshotRequest) -> EnvSnapshotRespon
     """Create a snapshot of the environment state."""
     handle = registry.get_env(request.env_id)
     if not handle:
-        raise HTTPException(
-            status_code=404, detail=f"Environment {request.env_id} not found"
-        )
+        raise HTTPException(status_code=404, detail=f"Environment {request.env_id} not found")
 
     try:
         # Serialize environment state
@@ -1030,9 +988,7 @@ async def restore_environment(request: EnvRestoreRequest) -> EnvRestoreResponse:
     """Restore an environment from a snapshot."""
     snapshot = registry.get_snapshot(request.snapshot_id)
     if not snapshot:
-        raise HTTPException(
-            status_code=404, detail=f"Snapshot {request.snapshot_id} not found"
-        )
+        raise HTTPException(status_code=404, detail=f"Snapshot {request.snapshot_id} not found")
 
     if snapshot.kind != "env":
         raise HTTPException(
@@ -1113,9 +1069,7 @@ async def restore_environment(request: EnvRestoreRequest) -> EnvRestoreResponse:
                     WordleEnvironment,
                 )
             except Exception as e:
-                raise HTTPException(
-                    status_code=500, detail=f"Wordle modules unavailable: {e}"
-                )
+                raise HTTPException(status_code=500, detail=f"Wordle modules unavailable: {e}")
 
             cfg = state_dict.get("config", {}) or {}
             word_length = int(cfg.get("word_length", 5))
@@ -1150,12 +1104,8 @@ async def restore_environment(request: EnvRestoreRequest) -> EnvRestoreResponse:
                     WordleEnvironmentWrapper as _WordleWrapper,
                 )
             except Exception as e:
-                raise HTTPException(
-                    status_code=500, detail=f"Wordle wrapper unavailable: {e}"
-                )
-            wrapper = await _WordleWrapper.deserialize(
-                payload=state_dict, env=base_env
-            )
+                raise HTTPException(status_code=500, detail=f"Wordle wrapper unavailable: {e}")
+            wrapper = await _WordleWrapper.deserialize(payload=state_dict, env=base_env)
 
             env_id = registry.register_env(
                 env=wrapper,
@@ -1184,14 +1134,10 @@ async def restore_environment(request: EnvRestoreRequest) -> EnvRestoreResponse:
                     SokobanEnvironment,
                 )
             except Exception as e:
-                raise HTTPException(
-                    status_code=500, detail=f"Sokoban modules unavailable: {e}"
-                )
+                raise HTTPException(status_code=500, detail=f"Sokoban modules unavailable: {e}")
 
             cfg = state_dict.get("config", {}) or {}
-            metadata = SokobanTaskInstanceMetadata(
-                difficulty=cfg.get("difficulty", "easy")
-            )
+            metadata = SokobanTaskInstanceMetadata(difficulty=cfg.get("difficulty", "easy"))
             instance = SokobanTaskInstance(
                 id=uuid4(),
                 impetus=Impetus(instructions="Restore"),
@@ -1211,12 +1157,8 @@ async def restore_environment(request: EnvRestoreRequest) -> EnvRestoreResponse:
                     SokobanEnvironmentWrapper as _SokobanWrapper,
                 )
             except Exception as e:
-                raise HTTPException(
-                    status_code=500, detail=f"Sokoban wrapper unavailable: {e}"
-                )
-            wrapper = await _SokobanWrapper.deserialize(
-                payload=state_dict, env=base_env
-            )
+                raise HTTPException(status_code=500, detail=f"Sokoban wrapper unavailable: {e}")
+            wrapper = await _SokobanWrapper.deserialize(payload=state_dict, env=base_env)
 
             env_id = registry.register_env(
                 env=wrapper,
@@ -1242,9 +1184,7 @@ async def restore_environment(request: EnvRestoreRequest) -> EnvRestoreResponse:
             )
 
     except Exception as e:
-        logger.error(
-            f"Failed to restore environment from snapshot {request.snapshot_id}: {e}"
-        )
+        logger.error(f"Failed to restore environment from snapshot {request.snapshot_id}: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
 
@@ -1253,9 +1193,7 @@ async def terminate_environment(request: EnvTerminateRequest) -> EnvTerminateRes
     """Terminate an environment and clean up resources."""
     handle = registry.get_env(request.env_id)
     if not handle:
-        raise HTTPException(
-            status_code=404, detail=f"Environment {request.env_id} not found"
-        )
+        raise HTTPException(status_code=404, detail=f"Environment {request.env_id} not found")
 
     try:
         # Call terminate on the environment

examples/warming_up_to_rl/task_app/synth_envs_hosted/envs/__init__.py

@@ -1 +1 @@
-"""Environment implementations."""
+"""Environment implementations."""

examples/warming_up_to_rl/task_app/synth_envs_hosted/envs/crafter/__init__.py

@@ -3,4 +3,4 @@
 from .environment import CrafterEnvironmentWrapper
 from .policy import CrafterPolicy
 
-__all__ = ["CrafterEnvironmentWrapper", "CrafterPolicy"]
+__all__ = ["CrafterEnvironmentWrapper", "CrafterPolicy"]

examples/warming_up_to_rl/task_app/synth_envs_hosted/envs/crafter/app.py

@@ -1 +1 @@
- # wraps hosted app
+# wraps hosted app