synth-ai 0.2.6.dev1__py3-none-any.whl → 0.4.3__py3-none-any.whl

synth_ai/{demos → cli/demo_apps}/demo_task_apps/core.py

@@ -3,12 +3,13 @@ from __future__ import annotations
 import json
 import os
 import subprocess
-import sys
-import time
+import urllib.request
 from dataclasses import dataclass
-from typing import Any, Dict, Optional, Tuple
+from typing import Any
 
-import urllib.request
+from synth_ai.core.env import PROD_BASE_URL_DEFAULT
+
+DEFAULT_TASK_APP_SECRET_NAME = "hendrycks-math-task-app-secret"
 
 
 @dataclass
@@ -18,7 +19,7 @@ class DemoEnv:
     env_api_key: str = ""
     task_app_base_url: str = ""
     task_app_name: str = ""
-    task_app_secret_name: str = ""
+    task_app_secret_name: str = DEFAULT_TASK_APP_SECRET_NAME
 
 
 def _mask(value: str, keep: int = 4) -> str:
@@ -31,7 +32,7 @@ def _state_path() -> str:
     return os.path.expanduser("~/.synth-ai/demo.json")
 
 
-def _read_state() -> Dict[str, Any]:
+def _read_state() -> dict[str, Any]:
     try:
         path = _state_path()
         if os.path.isfile(path):
@@ -43,7 +44,7 @@ def _read_state() -> Dict[str, Any]:
     return {}
 
 
-def _write_state(data: Dict[str, Any]) -> None:
+def _write_state(data: dict[str, Any]) -> None:
     try:
         path = _state_path()
         os.makedirs(os.path.dirname(path), exist_ok=True)
@@ -53,8 +54,8 @@ def _write_state(data: Dict[str, Any]) -> None:
         pass
 
 
-def load_dotenv_file(path: str) -> Dict[str, str]:
-    out: Dict[str, str] = {}
+def load_dotenv_file(path: str) -> dict[str, str]:
+    out: dict[str, str] = {}
     try:
         with open(path) as fh:
             for raw in fh:
@@ -68,7 +69,7 @@ def load_dotenv_file(path: str) -> Dict[str, str]:
     return out
 
 
-def _persist_dotenv_values(path: str, values: Dict[str, str]) -> None:
+def _persist_dotenv_values(path: str, values: dict[str, str]) -> None:
     """Ensure ``values`` are present in ``path`` (.env style)."""
 
     try:
@@ -78,7 +79,7 @@ def _persist_dotenv_values(path: str, values: Dict[str, str]) -> None:
                 existing_lines = fh.read().splitlines()
         else:
             os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
-        mapping: Dict[str, str] = {}
+        mapping: dict[str, str] = {}
         order: list[str] = []
         for line in existing_lines:
             if not line or line.startswith("#") or "=" not in line:
@@ -106,7 +107,7 @@ def _persist_dotenv_values(path: str, values: Dict[str, str]) -> None:
         pass
 
 
-def persist_dotenv_values(values: Dict[str, str], *, cwd: str | None = None) -> str:
+def persist_dotenv_values(values: dict[str, str], *, cwd: str | None = None) -> str:
     path = os.path.join(cwd or os.getcwd(), ".env")
     _persist_dotenv_values(path, values)
     return path
@@ -118,14 +119,41 @@ def persist_env_api_key(key: str) -> None:
     _write_state(data)
 
 
-def modal_auth_status() -> Tuple[bool, str]:
+def persist_demo_dir(demo_dir: str) -> None:
+    """Store the demo directory path for subsequent commands."""
+    data = _read_state()
+    data["DEMO_DIR"] = demo_dir
+    _write_state(data)
+
+
+def load_demo_dir() -> str | None:
+    """Load the stored demo directory path, if any."""
+    data = _read_state()
+    return data.get("DEMO_DIR")
+
+
+def persist_env_file_path(env_path: str) -> None:
+    """Store the .env file path for subsequent commands."""
+    data = _read_state()
+    data["ENV_FILE_PATH"] = env_path
+    _write_state(data)
+
+
+def load_env_file_path() -> str | None:
+    """Load the stored .env file path, if any."""
+    data = _read_state()
+    return data.get("ENV_FILE_PATH")
+
+
+def modal_auth_status() -> tuple[bool, str]:
     """Return (ok, message) describing Modal CLI credential status."""
 
     env_token_id = (os.environ.get("MODAL_TOKEN_ID") or "").strip()
     env_token_secret = (os.environ.get("MODAL_TOKEN_SECRET") or "").strip()
 
     try:
-        from modal.config import config as modal_config, user_config_path
+        from modal.config import config as modal_config
+        from modal.config import user_config_path
     except Exception as exc:  # pragma: no cover - modal optional in some envs
         return False, f"Modal client unavailable ({exc})"
 
@@ -169,7 +197,7 @@ def load_env() -> DemoEnv:
     Backend URL:
       - Use BACKEND_OVERRIDE (any) from CWD .env if set
       - Else use DEV_BACKEND_URL from CWD .env ONLY if it's localhost/127.0.0.1 or :8000
-      - Else default to prod https://agent-learning.onrender.com/api
+      - Else default to production backend (PROD_BASE_URL_DEFAULT)
 
     API keys:
       - SYNTH_API_KEY from OS -> CWD .env -> repo .env -> pkg demo .env -> state
@@ -180,7 +208,7 @@ def load_env() -> DemoEnv:
     """
     env = DemoEnv()
 
-    os_env: Dict[str, str] = dict(os.environ)
+    os_env: dict[str, str] = dict(os.environ)
 
     # CWD .env
     cwd_env_path = os.path.join(os.getcwd(), ".env")
@@ -189,27 +217,42 @@ def load_env() -> DemoEnv:
     # Repo/package .envs (fallbacks)
     repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../.."))
     repo_env = load_dotenv_file(os.path.join(repo_root, ".env"))
-    pkg_env = load_dotenv_file(os.path.join(repo_root, "synth_ai", "demos", "demo_task_apps", "math", ".env"))
+    pkg_env = load_dotenv_file(
+        os.path.join(repo_root, "synth_ai", "demos", "demo_task_apps", "math", ".env")
+    )
     examples_env = load_dotenv_file(os.path.join(repo_root, "examples", "rl", ".env"))
 
     state = _read_state()
 
+    default_root = PROD_BASE_URL_DEFAULT.rstrip("/")
+    prod_default = f"{default_root}/api"
+
     # Backend URL resolution
-    backend_override = (cwd_env.get("BACKEND_OVERRIDE") or "").strip()
-    dev_env = (cwd_env.get("DEV_BACKEND_URL") or "").strip()
-    use_dev = False
+    backend_override = (
+        os_env.get("BACKEND_OVERRIDE")
+        or cwd_env.get("BACKEND_OVERRIDE")
+        or repo_env.get("BACKEND_OVERRIDE")
+        or pkg_env.get("BACKEND_OVERRIDE")
+        or examples_env.get("BACKEND_OVERRIDE")
+        or ""
+    ).strip()
+    dev_env = (
+        os_env.get("DEV_BACKEND_URL")
+        or cwd_env.get("DEV_BACKEND_URL")
+        or repo_env.get("DEV_BACKEND_URL")
+        or pkg_env.get("DEV_BACKEND_URL")
+        or ""
+    ).strip()
     if backend_override:
         dev_url = backend_override
-        use_dev = True
     elif dev_env:
         lower = dev_env.lower()
         if "localhost" in lower or "127.0.0.1" in lower or lower.endswith(":8000"):
             dev_url = dev_env
-            use_dev = True
         else:
-            dev_url = "https://agent-learning.onrender.com/api"
+            dev_url = prod_default
     else:
-        dev_url = "https://agent-learning.onrender.com/api"
+        dev_url = prod_default
     if not dev_url.endswith("/api"):
         dev_url = dev_url.rstrip("/") + "/api"
 
@@ -222,7 +265,11 @@ def load_env() -> DemoEnv:
         or str(state.get("SYNTH_API_KEY") or "")
     )
     if not synth_api_key:
-        mode = "prod" if "agent-learning.onrender.com" in dev_url else ("local" if ("localhost" in dev_url or "127.0.0.1" in dev_url) else "dev")
+        mode = (
+            "prod"
+            if default_root in dev_url
+            else ("local" if ("localhost" in dev_url or "127.0.0.1" in dev_url) else "dev")
+        )
         if mode == "prod":
             synth_api_key = (
                 os_env.get("PROD_SYNTH_API_KEY")
@@ -267,7 +314,7 @@ def load_env() -> DemoEnv:
     )
 
     task_app_name = str(state.get("TASK_APP_NAME") or "")
-    task_app_secret_name = str(state.get("TASK_APP_SECRET_NAME") or "")
+    task_app_secret_name = str(state.get("TASK_APP_SECRET_NAME") or DEFAULT_TASK_APP_SECRET_NAME)
 
     env.dev_backend_url = dev_url.rstrip("/")
     env.synth_api_key = synth_api_key
@@ -276,22 +323,34 @@ def load_env() -> DemoEnv:
     env.task_app_name = task_app_name
     env.task_app_secret_name = task_app_secret_name
 
-    print("ENV:")
-    print(f"  DEV_BACKEND_URL={env.dev_backend_url}")
-    print(f"  SYNTH_API_KEY={_mask(env.synth_api_key)}")
-    print(f"  ENVIRONMENT_API_KEY={_mask(env.env_api_key)}")
-    print(f"  TASK_APP_BASE_URL={env.task_app_base_url}")
-    if task_app_name:
-        print(f"  TASK_APP_NAME={task_app_name}")
-    if task_app_secret_name:
-        print(f"  TASK_APP_SECRET_NAME={task_app_secret_name}")
+    # Suppress environment echo by default for cleaner CLI output.
+    # If needed for debugging, set SYNTH_CLI_VERBOSE=1 to print resolved values.
+    if os.getenv("SYNTH_CLI_VERBOSE", "0") == "1":
+        print("ENV:")
+        print(f"  DEV_BACKEND_URL={env.dev_backend_url}")
+        print(f"  SYNTH_API_KEY={_mask(env.synth_api_key)}")
+        print(f"  ENVIRONMENT_API_KEY={_mask(env.env_api_key)}")
+        print(f"  TASK_APP_BASE_URL={env.task_app_base_url}")
+        if task_app_name:
+            print(f"  TASK_APP_NAME={task_app_name}")
+        if task_app_secret_name:
+            print(f"  TASK_APP_SECRET_NAME={task_app_secret_name}")
     return env
 
 
-def assert_http_ok(url: str, method: str = "GET", allow_redirects: bool = True, timeout: float = 10.0) -> bool:
+def assert_http_ok(
+    url: str, method: str = "GET", allow_redirects: bool = True, timeout: float = 10.0
+) -> bool:
     try:
+        import ssl
+
         req = urllib.request.Request(url, method=method)
-        with urllib.request.urlopen(req, timeout=timeout) as resp:  # nosec - controlled URL
+        # Default: disable SSL verification for local/dev convenience.
+        # Set SYNTH_SSL_VERIFY=1 to enable verification.
+        ctx = ssl._create_unverified_context()  # nosec: disabled by default for dev
+        if os.getenv("SYNTH_SSL_VERIFY", "0") == "1":
+            ctx = None
+        with urllib.request.urlopen(req, timeout=timeout, context=ctx) as resp:  # nosec - controlled URL
             code = getattr(resp, "status", 200)
             return 200 <= int(code) < 400
     except Exception:
@@ -339,16 +398,17 @@ def persist_task_url(url: str, *, name: str | None = None) -> None:
         if data.get("TASK_APP_NAME") != name:
             data["TASK_APP_NAME"] = name
             changed.append("TASK_APP_NAME")
-        secret_name = f"{name}-secret"
-        if data.get("TASK_APP_SECRET_NAME") != secret_name:
-            data["TASK_APP_SECRET_NAME"] = secret_name
-            if "TASK_APP_NAME" not in changed:
-                changed.append("TASK_APP_SECRET_NAME")
+        if data.get("TASK_APP_SECRET_NAME") != DEFAULT_TASK_APP_SECRET_NAME:
+            data["TASK_APP_SECRET_NAME"] = DEFAULT_TASK_APP_SECRET_NAME
+            changed.append("TASK_APP_SECRET_NAME")
+    elif data.get("TASK_APP_SECRET_NAME") != DEFAULT_TASK_APP_SECRET_NAME:
+        data["TASK_APP_SECRET_NAME"] = DEFAULT_TASK_APP_SECRET_NAME
+        changed.append("TASK_APP_SECRET_NAME")
     _write_state(data)
     if changed:
         print(f"Saved {', '.join(changed)} to {_state_path()}")
-        if "TASK_APP_NAME" in changed or "TASK_APP_SECRET_NAME" in changed:
-            print(f"TASK_APP_SECRET_NAME={data.get('TASK_APP_SECRET_NAME', '')}")
+        if "TASK_APP_SECRET_NAME" in changed:
+            print(f"TASK_APP_SECRET_NAME={DEFAULT_TASK_APP_SECRET_NAME}")
 
 
 def persist_api_key(key: str) -> None:
@@ -357,18 +417,24 @@ def persist_api_key(key: str) -> None:
     _write_state(data)
 
 
-def run_job(env: DemoEnv, config_toml_path: str, *, batch_size: Optional[int] = None, group_size: Optional[int] = None, model: Optional[str] = None) -> None:
+def run_job(
+    env: DemoEnv,
+    config_toml_path: str,
+    *,
+    batch_size: int | None = None,
+    group_size: int | None = None,
+    model: str | None = None,
+) -> None:
     """Create and stream a short RL job using the backend API (placeholder: prints cURL to execute)."""
     backend = env.dev_backend_url.rstrip("/")
-    if backend.endswith("/api"):
-        api_base = backend
-    else:
-        api_base = backend + "/api"
+    api_base = backend if backend.endswith("/api") else backend + "/api"
     print("\nTo create an RL job, run:")
     print(
-        "curl -s -X POST \"" + api_base + "/rl/jobs\" "
+        'curl -s -X POST "' + api_base + '/rl/jobs" '
         "-H 'Content-Type: application/json' "
         f"-H 'Authorization: Bearer {env.synth_api_key}' "
         "-d '{"  # intentionally not fully formed here for brevity in this scaffold
     )
-    print("  NOTE: CLI implementation will build the full JSON body with inline TOML config and stream events.")
+    print(
+        "  NOTE: CLI implementation will build the full JSON body with inline TOML config and stream events."
+    )

synth_ai/cli/demo_apps/demo_task_apps/crafter/__init__.py

@@ -0,0 +1 @@
+# Crafter demo task app

synth_ai/cli/demo_apps/demo_task_apps/crafter/configs/crafter_fft_4b.toml

@@ -0,0 +1,53 @@
+# FFT job config for Qwen/Qwen3-4B on Crafter SFT dataset
+
+[algorithm]
+type = "offline"
+method = "supervised_finetune"
+variety = "fft"
+
+
+[job]
+model = "Qwen/Qwen3-4B"
+data = "ft_data/crafter_traces.jsonl"
+
+[compute]
+# Adjust as needed for your quota
+gpu_type = "H100"
+gpu_count = 1
+nodes = 1
+
+[data]
+# Optional topology metadata (left empty for now)
+topology = {}
+
+# Optional local validation dataset path (JSONL). If set, the client will upload
+# this file and wire up validation so the frontend can display val.loss.
+# validation_path = "../ft_data/crafter_validation.jsonl"
+
+[training]
+mode = "sft_offline"
+use_qlora = false
+
+# Validation settings to emit val.loss on the frontend
+[training.validation]
+enabled = true
+evaluation_strategy = "steps"
+eval_steps = 20
+save_best_model_at_end = true
+metric_for_best_model = "val.loss"
+greater_is_better = false
+
+[hyperparameters]
+# Minimal safe defaults; backend can override
+n_epochs = 1
+batch_size = 1
+gradient_accumulation_steps = 64
+sequence_length = 4096
+learning_rate = 5e-6
+warmup_ratio = 0.03
+train_kind = "fft"
+
+# Optional parallelism block example
+#[hyperparameters.parallelism]
+# tensor_parallel_size = 1
+# pipeline_parallel_size = 1

synth_ai/cli/demo_apps/demo_task_apps/crafter/configs/rl_from_base_qwen4b.toml

@@ -0,0 +1,73 @@
+# RL training starting from base Qwen/Qwen3-4B (TOML-only model selection)
+
+[algorithm]
+type = "online"
+method = "policy_gradient"
+variety = "gspo"
+
+
+[services]
+task_url = "https://synth-laboratories--grpo-crafter-task-app-final-warming--ceb5b2.modal.run"
+
+[compute]
+# Cluster shape for RL pipeline
+gpu_type = "H100"
+gpu_count = 8
+
+[topology]
+# Split GPUs across vLLM, training, and reference
+# Must sum to compute.gpu_count
+type = "single_node_split"
+gpus_for_vllm = 4
+gpus_for_training = 3
+gpus_for_ref = 1
+tensor_parallel = 4
+
+[vllm]
+# Serving tensor parallel size
+tensor_parallel_size = 4
+max_model_len = 8192
+
+[reference]
+# Required by trainer/runtime; ensures dedicated/scoped scoring server config exists
+placement = "dedicated"
+port = 8002
+tp = 1
+health_max_wait_s = 180
+health_interval_ms = 300
+
+[model]
+# Base model start
+base = "Qwen/Qwen3-4B"
+label = "crafter-rl-from-base"
+
+[rollout]
+max_turns = 10
+episodes_per_batch = 64
+policy_name = "crafter"
+
+[evaluation]
+# Run baseline evaluation over the first 100 seeds every 20 training iterations
+instances = 10
+every_n_iters = 10
+seeds = [
+  0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+]
+
+[training]
+log_interval = 1
+weight_sync_interval = 1
+# Additional RL hyperparameters can go here
+
+# Stepwise rewards (Crafter decision-level)
+step_rewards_enabled = true
+step_rewards_mode = "decision_stepwise"  # "off" | "decision_stepwise" | "env_sparse"
+step_rewards_beta = 0.0
+step_rewards_indicator_lambda = 1.0
+# Optional selector for decision scalar: "unique" | "absolute" (default unique)
+event_rewards_kind = "unique"
+
+[training.weight_sync]
+enable  = true
+targets = ["policy"]
+weight_sync_interval = 1

synth_ai/cli/demo_apps/demo_task_apps/crafter/grpo_crafter_task_app.py

@@ -0,0 +1,185 @@
+"""Compatibility wrapper for the GRPO Crafter task app.
+
+This module now delegates to the TaskAppConfig defined in the local example at
+`examples/task_apps/crafter/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 deploy --runtime uvicorn grpo-crafter` for local development and testing.
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+from pathlib import Path
+
+from fastapi.exceptions import RequestValidationError
+from fastapi.responses import JSONResponse
+from starlette.requests import Request
+
+from synth_ai.sdk.task.apps import ModalDeploymentConfig, registry
+from synth_ai.sdk.task.auth import is_api_key_header_authorized, normalize_environment_api_key
+from synth_ai.sdk.task.server import TaskAppConfig, create_task_app, run_task_app
+
+
+def _load_build_config():
+    """Load the example's build_config, preferring package import with file fallback."""
+    # First try to import by package name (installed 'examples' package)
+    try:
+        module = importlib.import_module("examples.task_apps.crafter.task_app.grpo_crafter")
+        return module.build_config  # type: ignore[attr-defined]
+    except Exception:
+        # Fallback: locate the file within the installed synth_ai distribution and exec it
+        import sys as _sys
+
+        import synth_ai
+
+        synth_ai_path = Path(synth_ai.__file__ or Path(__file__).resolve()).resolve().parent.parent
+        module_path = (
+            synth_ai_path / "examples" / "task_apps" / "crafter" / "task_app" / "grpo_crafter.py"
+        )
+
+        if not module_path.exists():
+            raise ImportError(
+                f"Could not find task app module at {module_path}. Make sure you're running from the synth-ai repository."
+            ) from None
+
+        spec = importlib.util.spec_from_file_location(
+            "examples.task_apps.crafter.task_app.grpo_crafter", module_path
+        )
+        if spec is None or spec.loader is None:
+            raise ImportError(f"Could not load task app module at {module_path}") from None
+
+        module = importlib.util.module_from_spec(spec)
+        _sys.modules[spec.name] = module
+        spec.loader.exec_module(module)
+        return module.build_config  # type: ignore[attr-defined]
+
+
+build_config = _load_build_config()
+
+
+APP_ID = "grpo-crafter-task-app"
+
+
+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)
+except Exception:  # pragma: no cover - registry unavailable in some contexts
+    MODAL_DEPLOYMENT: ModalDeploymentConfig | None = None
+    ENV_FILES: tuple[str, ...] = ()
+else:
+    MODAL_DEPLOYMENT = _REGISTERED_ENTRY.modal
+    ENV_FILES = tuple(_REGISTERED_ENTRY.env_files)
+
+
+def build_task_app_config() -> TaskAppConfig:
+    """Return a fresh TaskAppConfig for this wrapper."""
+
+    base = _build_base_config()
+    return base.clone()
+
+
+def fastapi_app():
+    """Return the FastAPI application for Modal or other ASGI hosts."""
+
+    app = create_task_app(build_task_app_config())
+
+    # Replace default health endpoints so we can permit soft auth failures and log 422s.
+    filtered_routes = []
+    for route in app.router.routes:
+        path = getattr(route, "path", None)
+        methods = getattr(route, "methods", set()) or set()
+        if path in {"/health", "/health/rollout"} and "GET" in methods:
+            continue
+        filtered_routes.append(route)
+    app.router.routes = filtered_routes
+
+    def _log_env_key_prefix(source: str, env_key: str | None) -> str | None:
+        if not env_key:
+            return None
+        prefix = env_key[: max(1, len(env_key) // 2)]
+        print(f"[{source}] expected ENVIRONMENT_API_KEY prefix: {prefix}")
+        return prefix
+
+    @app.get("/health")
+    async def health(request: Request):
+        env_key = normalize_environment_api_key()
+        if not env_key:
+            return JSONResponse(
+                status_code=503,
+                content={"status": "unhealthy", "detail": "Missing ENVIRONMENT_API_KEY"},
+            )
+        if not is_api_key_header_authorized(request):
+            prefix = _log_env_key_prefix("health", env_key)
+            content = {"status": "healthy", "authorized": False}
+            if prefix:
+                content["expected_api_key_prefix"] = prefix
+            return JSONResponse(status_code=200, content=content)
+        return {"status": "healthy", "authorized": True}
+
+    @app.get("/health/rollout")
+    async def health_rollout(request: Request):
+        env_key = normalize_environment_api_key()
+        if not env_key:
+            return JSONResponse(
+                status_code=503,
+                content={"status": "unhealthy", "detail": "Missing ENVIRONMENT_API_KEY"},
+            )
+        if not is_api_key_header_authorized(request):
+            prefix = _log_env_key_prefix("health/rollout", env_key)
+            content = {"status": "healthy", "authorized": False}
+            if prefix:
+                content["expected_api_key_prefix"] = prefix
+            return JSONResponse(status_code=200, content=content)
+        return {"ok": True, "authorized": True}
+
+    @app.exception_handler(RequestValidationError)
+    async def _on_validation_error(request: Request, exc: RequestValidationError):
+        try:
+            hdr = request.headers
+            snapshot = {
+                "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")),
+                "errors": exc.errors()[:5],
+            }
+            print("[422] validation", snapshot, flush=True)
+        except Exception:
+            pass
+        return JSONResponse(
+            status_code=422,
+            content={"status": "invalid", "detail": exc.errors()[:5]},
+        )
+
+    return app
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run the Crafter task app locally")
+    parser.add_argument("--host", default="0.0.0.0")
+    parser.add_argument("--port", type=int, default=8001)
+    parser.add_argument("--reload", action="store_true", help="Enable uvicorn autoreload")
+    parser.add_argument(
+        "--env-file",
+        action="append",
+        default=[],
+        help="Additional .env files to load before startup",
+    )
+    args = parser.parse_args()
+
+    default_env = Path(__file__).resolve().parents[4] / "backend" / ".env.dev"
+    env_files = [str(default_env)] if default_env.exists() else []
+    env_files.extend(args.env_file or [])
+
+    run_task_app(
+        build_task_app_config,
+        host=args.host,
+        port=args.port,
+        reload=args.reload,
+        env_files=env_files,
+    )

synth_ai/cli/demo_apps/demo_task_apps/math/_common.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+"""Minimal helpers for the math task app.
+
+This module provides a local fallback for install_problem_bank_into_shared so
+the modal task app can import it without requiring an external math_rl package.
+"""
+
+
+def install_problem_bank_into_shared() -> None:
+    """No-op placeholder for installing the Hendrycks MATH problem bank.
+
+    In production deployments, this can download or unpack the problem bank
+    into a shared directory. For the demo scaffold, it is a no-op.
+    """
+    return None

synth_ai/{demos → cli/demo_apps}/demo_task_apps/math/app.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os
+
 from fastapi import FastAPI
 from starlette.middleware.cors import CORSMiddleware
 
@@ -11,7 +12,7 @@ except Exception:  # fallback path when imported from repo root
     try:
         from examples.rl.task_app import make_app as make_rl_app  # type: ignore
     except Exception as e:  # pragma: no cover
-        raise ImportError(f"Unable to import RL task app: {e}")
+        raise ImportError(f"Unable to import RL task app: {e}") from e
 
 
 def create_app() -> FastAPI: