synth-ai 0.2.9.dev7__py3-none-any.whl → 0.2.10__py3-none-any.whl

examples/warming_up_to_rl/task_app/grpo_crafter.py

@@ -1,42 +1,123 @@
-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, RolloutMetrics
+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,
+}
+
+_HERE = Path(__file__).resolve()
+
+
+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
 
-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"
+    for parent in _HERE.parents:
+        candidate = parent.resolve()
+        if (candidate / "synth_envs_hosted").is_dir():
+            return candidate
 
-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)
+    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
+    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
@@ -44,11 +125,23 @@ try:
     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
@@ -121,16 +214,16 @@ 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]
@@ -156,7 +249,7 @@ 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
@@ -165,14 +258,14 @@ class CrafterDataset:
         return "custom"
 
     @property
-    def seed_range(self) -> List[int]:
+    def seed_range(self) -> list[int]:
         return [self.seed_min, self.seed_max]
 
 
-def _compute_world_traits(env: "crafter.Env", radius: int = 10) -> Dict[str, int]:
+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
+    from crafter import objects as _objects  # type: ignore
 
     player = getattr(env, "_player", None)
     if player is None:
@@ -185,7 +278,7 @@ def _compute_world_traits(env: "crafter.Env", radius: int = 10) -> Dict[str, int
         if obj is None or obj is player:
             continue
         try:
-            if _np.abs(getattr(obj, "pos") - pos).sum() > radius:
+            if _np.abs(obj.pos - pos).sum() > radius:
                 continue
         except Exception:
             continue
@@ -193,14 +286,12 @@ def _compute_world_traits(env: "crafter.Env", radius: int = 10) -> Dict[str, int
             counts["trees"] += 1
         elif isinstance(obj, _objects.Cow):
             counts["cows"] += 1
-        elif isinstance(obj, (_objects.Zombie, _objects.Skeleton)):
+        elif isinstance(obj, _objects.Zombie | _objects.Skeleton):
             counts["hostiles"] += 1
     return counts
 
 
 def env_value(key: str, default: Any) -> Any:
-    import os
-
     return os.getenv(key, default)
 
 
@@ -217,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.",
@@ -289,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,
@@ -351,6 +442,82 @@ 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:
     # If hosted env service code is not bundled, return a no-op rollout response compatible with contracts
     if not HAS_HOSTED:
@@ -370,19 +537,49 @@ async def rollout_executor(request: RolloutRequest, fastapi_request) -> RolloutR
             trace=None,
         )
 
-    converted_ops: List[str] = [_normalise_op(op, idx) for idx, op in enumerate(request.ops)]
+    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()),
@@ -418,7 +615,7 @@ def build_config() -> TaskAppConfig:
     )
     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,
@@ -436,7 +633,7 @@ 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]):
@@ -489,10 +686,12 @@ register_task_app(
                 "crafter",
             ),
             extra_local_dirs=(
+                # 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

@@ -14,12 +14,11 @@ 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"
 
@@ -104,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"]

examples/warming_up_to_rl/task_app/synth_envs_hosted/branching.py

@@ -1,13 +1,11 @@
 from __future__ import annotations
 
 import logging
-from typing import Dict, List, Optional
 
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
 
 from .registry import registry
-from .storage.volume import storage
 
 logger = logging.getLogger(__name__)
 
@@ -15,15 +13,15 @@ router = APIRouter()
 
 
 class BranchRequest(BaseModel):
-    env_ids: Optional[List[str]] = None
-    policy_ids: Optional[List[str]] = None
+    env_ids: list[str] | None = None
+    policy_ids: list[str] | None = None
     num_children: int = 1
     max_branches: int = 10
 
 
 class BranchResponse(BaseModel):
-    env_branches: Dict[str, List[str]]
-    policy_branches: Dict[str, List[str]]
+    env_branches: dict[str, list[str]]
+    policy_branches: dict[str, list[str]]
 
 
 @router.post("/branch", response_model=BranchResponse)
@@ -53,8 +51,8 @@ async def create_branches(request: BranchRequest) -> BranchResponse:
                 for child_idx in range(request.num_children):
                     # Create snapshot of parent
                     from .environment_routes import (
-                        snapshot_environment,
                         EnvSnapshotRequest,
+                        snapshot_environment,
                     )
 
                     snapshot_response = await snapshot_environment(
@@ -63,8 +61,8 @@ async def create_branches(request: BranchRequest) -> BranchResponse:
 
                     # Restore to new environment with modified seed
                     from .environment_routes import (
-                        restore_environment,
                         EnvRestoreRequest,
+                        restore_environment,
                     )
 
                     restore_response = await restore_environment(
@@ -100,14 +98,14 @@ async def create_branches(request: BranchRequest) -> BranchResponse:
 
                 for child_idx in range(request.num_children):
                     # Create snapshot of parent
-                    from .policy_routes import snapshot_policy, PolicySnapshotRequest
+                    from .policy_routes import PolicySnapshotRequest, snapshot_policy
 
                     snapshot_response = await snapshot_policy(
                         PolicySnapshotRequest(policy_id=policy_id)
                     )
 
                     # Restore to new policy
-                    from .policy_routes import restore_policy, PolicyRestoreRequest
+                    from .policy_routes import PolicyRestoreRequest, restore_policy
 
                     restore_response = await restore_policy(
                         PolicyRestoreRequest(snapshot_id=snapshot_response.snapshot_id)
@@ -142,4 +140,4 @@ async def create_branches(request: BranchRequest) -> BranchResponse:
 
     except Exception as e:
         logger.error(f"Failed to create branches: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=500, detail=str(e)) from e