synth-ai 0.2.9.dev4__py3-none-any.whl → 0.2.9.dev6__py3-none-any.whl

examples/warming_up_to_rl/task_app/grpo_crafter.py

@@ -1,60 +1,156 @@
-from __future__ import annotations
-
 """Task App configuration for the GRPO Crafter example."""
 
+from __future__ import annotations
+
+import logging
 import os
 import sys
+from collections.abc import Iterable, Sequence
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Dict, Iterable, List, Sequence
+from typing import Any
 
-from synth_ai.task.contracts import RolloutRequest, RolloutResponse, TaskInfo
+from synth_ai.task.apps import ModalDeploymentConfig, TaskAppEntry, register_task_app
+from synth_ai.task.contracts import RolloutMetrics, RolloutRequest, RolloutResponse, TaskInfo
 from synth_ai.task.datasets import TaskDatasetRegistry, TaskDatasetSpec
+from synth_ai.task.json import to_jsonable  # noqa: F401  (imported for side-effect compatibility)
 from synth_ai.task.rubrics import load_rubric
 from synth_ai.task.server import ProxyConfig, RubricBundle, TaskAppConfig
-from synth_ai.task.json import to_jsonable  # noqa: F401  (imported for side-effect compatibility)
-from synth_ai.task.apps import ModalDeploymentConfig, TaskAppEntry, register_task_app
 from synth_ai.task.tracing_utils import (
     build_tracer_factory,
     resolve_sft_output_dir,
     resolve_tracing_db_url,
     tracing_env_enabled,
 )
-
 from synth_ai.tracing_v3.session_tracer import SessionTracer
 
+logger = logging.getLogger(__name__)
+
+DEFAULT_ALIAS_OPS: list[str] = ["agent", "env"] * 10
+DEFAULT_ALIAS_STEP_REWARDS: dict[str, Any] = {
+    "enabled": True,
+    "mode": "decision_stepwise",
+    "indicator_lambda": 1.0,
+    "step_beta": 0.0,
+}
 
-REPO_ROOT = Path(__file__).resolve().parents[3]
-TASK_APP_ROOT = REPO_ROOT / "examples" / "warming_up_to_rl" / "task_app"
-SYNTH_ENVS_HOSTED_ROOT = TASK_APP_ROOT / "synth_envs_hosted"
+_HERE = Path(__file__).resolve()
 
-for path in [REPO_ROOT, TASK_APP_ROOT, SYNTH_ENVS_HOSTED_ROOT]:
-    path_str = str(path)
-    if path_str not in sys.path:
-        sys.path.insert(0, path_str)
 
+def _resolve_repo_root() -> Path:
+    """Best-effort detection of the Synth AI repo root across local and Modal mounts."""
+
+    candidates: list[Path] = []
+    env_root = os.getenv("SYNTH_AI_REPO_ROOT")
+    if env_root:
+        candidates.append(Path(env_root).expanduser())
+    candidates.append(Path("/opt/synth_ai_repo"))
+    candidates.extend(parent for parent in [_HERE.parent, *_HERE.parents])
+
+    for candidate in candidates:
+        try:
+            resolved = candidate.resolve()
+        except Exception:
+            continue
+        if not resolved.exists():
+            continue
+        if (resolved / "pyproject.toml").exists() or (resolved / "uv.lock").exists():
+            return resolved
+        if (resolved / "synth_ai").is_dir():
+            return resolved
+
+    try:
+        return _HERE.parents[3]
+    except IndexError:
+        return _HERE.parent
+
+
+def _resolve_task_app_root(repo_root: Path) -> Path:
+    """Locate the task_app directory even when the module is copied to a temp mount."""
+
+    preferred = (repo_root / "examples" / "warming_up_to_rl" / "task_app").resolve()
+    if preferred.is_dir():
+        return preferred
+
+    local_parent = _HERE.parent.resolve()
+    if (local_parent / "synth_envs_hosted").is_dir():
+        return local_parent
+
+    for parent in _HERE.parents:
+        candidate = parent.resolve()
+        if (candidate / "synth_envs_hosted").is_dir():
+            return candidate
+
+    fallback = Path("/opt/synth_ai_repo/examples/warming_up_to_rl/task_app")
+    if fallback.is_dir():
+        return fallback.resolve()
+
+    return local_parent
+
+
+REPO_ROOT = _resolve_repo_root()
+TASK_APP_ROOT = _resolve_task_app_root(REPO_ROOT)
+SYNTH_ENVS_HOSTED_ROOT = (TASK_APP_ROOT / "synth_envs_hosted").resolve()
+
+EXAMPLES_ROOT = (REPO_ROOT / "examples").resolve()
+
+for path in (REPO_ROOT, TASK_APP_ROOT, SYNTH_ENVS_HOSTED_ROOT, EXAMPLES_ROOT):
+    try:
+        resolved = path.resolve()
+    except Exception:
+        resolved = path
+    if resolved.exists():
+        path_str = str(resolved)
+        if path_str not in sys.path:
+            sys.path.insert(0, path_str)
+
+# Fallback: explicitly add Modal mount path for 'examples' if REPO_ROOT detection fails
+try:
+    _hard_examples = Path("/opt/synth_ai_repo/examples")
+    if _hard_examples.exists():
+        _hard_examples_str = str(_hard_examples.resolve())
+        if _hard_examples_str not in sys.path:
+            sys.path.insert(0, _hard_examples_str)
+except Exception:
+    pass
+
+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 (
+    import crafter.constants as crafter_constants  # type: ignore
+    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,
+    )
+    from synth_envs_hosted.rollout import (
         RolloutPolicySpec as LegacyRolloutPolicySpec,
+    )
+    from synth_envs_hosted.rollout import (
         RolloutRecordConfig as LegacyRolloutRecordConfig,
+    )
+    from synth_envs_hosted.rollout import (
         RolloutRequest as LegacyRolloutRequest,
+    )
+    from synth_envs_hosted.rollout import (
         RolloutResponse as LegacyRolloutResponse,
+    )
+    from synth_envs_hosted.rollout import (
         RolloutSafetyConfig as LegacyRolloutSafetyConfig,
+    )
+    from synth_envs_hosted.rollout import (
         execute_rollout as legacy_execute_rollout,
     )
 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 +170,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 = (
@@ -114,23 +214,23 @@ class CrafterDataset:
         area_env = env_value("CRAFTER_AREA", "64,64")
         self.area = tuple(int(x) for x in str(area_env).split(","))
         self.length = int(env_value("CRAFTER_EPISODE_LENGTH", 10000))
-        self._cache: Dict[int, Dict[str, Any]] = {}
+        self._cache: dict[int, dict[str, Any]] = {}
 
-    def config_for_seed(self, seed: int) -> Dict[str, Any]:
+    def config_for_seed(self, seed: int) -> dict[str, Any]:
         return {
             "seed": int(seed),
             "area": list(self.area),
             "length": self.length,
         }
 
-    def describe_seed(self, seed: int) -> Dict[str, Any]:
+    def describe_seed(self, seed: int) -> dict[str, Any]:
         seed = int(seed)
         if seed in self._cache:
             return self._cache[seed]
         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)
@@ -149,23 +249,49 @@ class CrafterDataset:
         self._cache[seed] = summary
         return summary
 
-    def _difficulty(self, traits: Dict[str, int]) -> str:
+    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"
 
     @property
-    def seed_range(self) -> List[int]:
+    def seed_range(self) -> list[int]:
         return [self.seed_min, self.seed_max]
 
 
-def env_value(key: str, default: Any) -> Any:
-    import os
+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
+    import numpy as _np  # type: ignore
+    from crafter import objects as _objects  # 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(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:
     return os.getenv(key, default)
 
 
@@ -182,8 +308,8 @@ def _base_task_info(dataset: CrafterDataset) -> TaskInfo:
         environments=["crafter"],
         action_space={
             "type": "discrete",
-            "size": len(C.actions),
-            "actions": list(C.actions),
+            "size": len(crafter_constants.actions),
+            "actions": list(crafter_constants.actions),
         },
         observation={
             "summary": "RGB frame plus inventory, achievements, and semantic map patches.",
@@ -254,7 +380,7 @@ EVENTS_RUBRIC = load_rubric(
 )
 
 
-def describe_taskset(dataset: CrafterDataset) -> Dict[str, Any]:
+def describe_taskset(dataset: CrafterDataset) -> dict[str, Any]:
     return {
         **DATASET_SPEC.model_dump(),
         "seed_range": dataset.seed_range,
@@ -266,7 +392,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)
@@ -314,20 +442,144 @@ def _normalise_op(op_value: Any, index: int) -> str:
     raise ValueError(f"Unsupported op type '{candidate}' at index {index}")
 
 
+def _coerce_math_to_crafter(request: RolloutRequest) -> RolloutRequest:
+    """Map legacy math env/policy names to crafter and enrich rollout defaults."""
+
+    def _needs_crafter(name: str | None) -> bool:
+        if not name:
+            return False
+        lowered = str(name).strip().lower()
+        return lowered.startswith("math")
+
+    env_updates: dict[str, Any] = {}
+    policy_updates: dict[str, Any] = {}
+    alias_applied = False
+
+    if _needs_crafter(request.env.env_name):
+        env_updates["env_name"] = "crafter"
+        alias_applied = True
+    if request.env.env_id and _needs_crafter(request.env.env_id):
+        env_updates["env_id"] = None
+        alias_applied = True
+    if _needs_crafter(request.policy.policy_name):
+        policy_updates["policy_name"] = "crafter-react"
+        alias_applied = True
+    if request.policy.policy_id and _needs_crafter(request.policy.policy_id):
+        policy_updates["policy_id"] = None
+        alias_applied = True
+
+    if not alias_applied:
+        return request
+
+    updated_env = request.env.model_copy(update=env_updates) if env_updates else request.env
+    updated_policy = (
+        request.policy.model_copy(update=policy_updates) if policy_updates else request.policy
+    )
+
+    env_cfg = dict(updated_env.config or {})
+    env_cfg.setdefault("difficulty", "normal")
+    env_cfg.setdefault("step_rewards", dict(DEFAULT_ALIAS_STEP_REWARDS))
+    env_cfg.setdefault("env_params", {"max_steps_per_episode": 200})
+    updated_env = updated_env.model_copy(update={"config": env_cfg})
+
+    policy_cfg = dict(updated_policy.config or {})
+    policy_cfg.setdefault("max_llm_calls", 10)
+    policy_cfg.setdefault("max_completion_tokens", 1024)
+    policy_cfg.setdefault("temperature", 0.2)
+    policy_cfg.setdefault("step_rewards", dict(DEFAULT_ALIAS_STEP_REWARDS))
+    updated_policy = updated_policy.model_copy(update={"config": policy_cfg})
+
+    ops_override = request.ops
+    if not ops_override or len(ops_override) < len(DEFAULT_ALIAS_OPS):
+        ops_override = list(DEFAULT_ALIAS_OPS)
+
+    coerced = request.model_copy(update={"env": updated_env, "policy": updated_policy, "ops": ops_override})
+
+    try:
+        print(
+            "[rollout] remapped math request -> crafter "
+            f"(env={request.env.env_name!r}→{coerced.env.env_name!r}, "
+            f"policy={request.policy.policy_name!r}→{coerced.policy.policy_name!r})",
+            flush=True,
+        )
+    except Exception:
+        pass
+    try:
+        logger.info(
+            "ROLLOUT_ALIAS: remapped math env/policy to crafter (env=%s→%s, policy=%s→%s)",
+            request.env.env_name,
+            coerced.env.env_name,
+            request.policy.policy_name,
+            coerced.policy.policy_name,
+        )
+    except Exception:
+        pass
+
+    return coerced
+
+
 async def rollout_executor(request: RolloutRequest, fastapi_request) -> RolloutResponse:
-    converted_ops: List[str] = [_normalise_op(op, idx) for idx, op in enumerate(request.ops)]
+    # 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,
+        )
+
+    request = _coerce_math_to_crafter(request)
+
+    policy_cfg = dict(request.policy.config or {})
+    try:
+        max_llm_calls = int(policy_cfg.get("max_llm_calls") or 10)
+    except Exception:
+        max_llm_calls = 10
+    policy_cfg.setdefault("max_llm_calls", max_llm_calls)
+    policy_cfg.setdefault("max_tokens", 512)
+    policy_cfg.setdefault("max_completion_tokens", 512)
+    policy_cfg.setdefault("temperature", 0.2)
+    policy_cfg.setdefault("top_p", 0.95)
+
+    env_cfg = dict(request.env.config or {})
+    env_params = dict(env_cfg.get("env_params") or {})
+    try:
+        max_steps_episode = int(env_params.get("max_steps_per_episode") or max_llm_calls)
+    except Exception:
+        max_steps_episode = max_llm_calls
+    desired_steps = max(max_llm_calls, max_steps_episode)
+    env_params["max_steps_per_episode"] = int(desired_steps)
+    env_cfg["env_params"] = env_params
+
+    updated_policy = request.policy.model_copy(update={"config": policy_cfg})
+    updated_env = request.env.model_copy(update={"config": env_cfg})
+    request = request.model_copy(update={"policy": updated_policy, "env": updated_env})
+
+    converted_ops: list[str] = [_normalise_op(op, idx) for idx, op in enumerate(request.ops)]
+    max_ops_allowed = max_llm_calls * 2 if max_llm_calls > 0 else len(converted_ops)
+    if max_ops_allowed and len(converted_ops) > max_ops_allowed:
+        converted_ops = converted_ops[:max_ops_allowed]
     legacy_request = LegacyRolloutRequest(
         run_id=request.run_id,
         env=LegacyRolloutEnvSpec(
             env_id=request.env.env_id,
             env_name=request.env.env_name,
-            config=request.env.config or {},
+            config=env_cfg,
             seed=request.env.seed,
         ),
         policy=LegacyRolloutPolicySpec(
             policy_id=request.policy.policy_id,
             policy_name=request.policy.policy_name,
-            config=request.policy.config or {},
+            config=policy_cfg,
         ),
         ops=converted_ops,
         record=LegacyRolloutRecordConfig(**request.record.model_dump()),
@@ -338,7 +590,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,14 +606,16 @@ 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] = {
+    app_state: dict[str, Any] = {
         "task_app": hosted_task_app,
         "allowed_environments": ["crafter"],
         "tracing_enabled": tracing_enabled,
@@ -377,12 +633,14 @@ def build_config() -> TaskAppConfig:
     if sft_output_dir:
         print(f"[task:sft] writing JSONL to {sft_output_dir}", flush=True)
 
-    def _describe_taskset() -> Dict[str, Any]:
+    def _describe_taskset() -> dict[str, Any]:
         return describe_taskset(dataset)
 
     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 +651,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,10 +686,12 @@ 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'),
+                # Mount repo root so local modules resolve when deployed on Modal
+                (str(REPO_ROOT), "/opt/synth_ai_repo"),
+                (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"),
+            secret_names=("groq-api-key", "openai-api-key"),
             memory=16384,
             cpu=4.0,
             max_containers=10,

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.
 """
 
@@ -15,37 +14,19 @@ from pathlib import Path
 from fastapi.exceptions import RequestValidationError
 from fastapi.responses import JSONResponse
 from starlette.requests import Request
-
 from synth_ai.task.apps import ModalDeploymentConfig, registry
-from .grpo_crafter import build_config
 from synth_ai.task.auth import is_api_key_header_authorized, normalize_environment_api_key
 from synth_ai.task.server import TaskAppConfig, create_task_app, run_task_app
 
+from .grpo_crafter import build_config
 
 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 +40,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():
@@ -122,7 +103,7 @@ def fastapi_app():
         try:
             hdr = request.headers
             snapshot = {
-                "path": str(getattr(request, "url").path),
+                "path": str(request.url.path),
                 "have_x_api_key": bool(hdr.get("x-api-key")),
                 "have_x_api_keys": bool(hdr.get("x-api-keys")),
                 "have_authorization": bool(hdr.get("authorization")),

examples/warming_up_to_rl/task_app/synth_envs_hosted/__init__.py

@@ -1,5 +1,5 @@
 """GRPO Synth Envs Hosted Service."""
 
-from .hosted_app import create_app, TaskApp
+from .hosted_app import TaskApp, create_app
 
 __all__ = ["create_app", "TaskApp"]