synth-ai 0.2.13.dev1__py3-none-any.whl → 0.2.14__py3-none-any.whl

examples/warming_up_to_rl/run_local_rollout.py

@@ -42,8 +42,10 @@ def build_rollout_request(
         trace_format=trace_format,
         return_trace=return_trace,
     )
+    from synth_ai.task.contracts import RolloutMode
     return RolloutRequest(
         run_id=run_id,
+        mode=RolloutMode.EVAL,
         env=RolloutEnvSpec(env_name="crafter", seed=seed, config={}),
         policy=RolloutPolicySpec(policy_name="crafter-react", config=policy_config),
         ops=ops,

examples/warming_up_to_rl/run_local_rollout_modal.py

@@ -33,12 +33,14 @@ def build_rollout_request(
             "Authorization": f"Bearer {api_key}",
         },
     }
+    from synth_ai.task.contracts import RolloutMode
     return RolloutRequest(
         run_id=run_id,
         env=RolloutEnvSpec(env_name="crafter", seed=seed, config={}),
         policy=RolloutPolicySpec(policy_name="crafter-react", config=policy_config),
         ops=ops,
         record=RolloutRecordConfig(trajectories=True),
+        mode=RolloutMode.EVAL,
         on_done="reset",
         safety=RolloutSafetyConfig(),
     )

examples/warming_up_to_rl/run_local_rollout_parallel.py

@@ -46,12 +46,14 @@ def build_rollout_request(
         trace_format=trace_format,
         return_trace=return_trace,
     )
+    from synth_ai.task.contracts import RolloutMode
     return RolloutRequest(
         run_id=run_id,
         env=RolloutEnvSpec(env_name="crafter", seed=seed, config={}),
         policy=RolloutPolicySpec(policy_name="crafter-react", config=policy_config),
         ops=ops,
         record=record_cfg,
+        mode=RolloutMode.EVAL,
         on_done="reset",
         safety=RolloutSafetyConfig(),
     )

examples/warming_up_to_rl/run_local_rollout_traced.py

@@ -53,12 +53,14 @@ def build_rollout_request(
         trace_format=trace_format,
     )
 
+    from synth_ai.task.contracts import RolloutMode
     return RolloutRequest(
         run_id=run_id,
         env=RolloutEnvSpec(env_name="crafter", seed=seed, config={}),
         policy=RolloutPolicySpec(policy_name="crafter-react", config=policy_config),
         ops=ops,
         record=record,
+        mode=RolloutMode.EVAL,
         on_done="reset",
         safety=RolloutSafetyConfig(),
     )

examples/warming_up_to_rl/run_rollout_remote.py

@@ -60,12 +60,14 @@ def build_request(
     for _ in range(max(llm_calls, 1)):
         ops.extend(["agent", "env"])
 
+    from synth_ai.task.contracts import RolloutMode
     return RolloutRequest(
         run_id=run_id,
         env=RolloutEnvSpec(env_name="crafter", seed=seed, config={}),
         policy=RolloutPolicySpec(policy_name="crafter-react", config=policy_config),
         ops=ops,
         record=RolloutRecordConfig(trajectories=True),
+        mode=RolloutMode.EVAL,
         on_done="reset",
         safety=RolloutSafetyConfig(),
     )

examples/workflows/math_rl/download_dataset.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""Download subsets of the MATH dataset to local JSONL files."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+from datasets import load_dataset
+
+
+def extract_examples(dataset: Any, *, limit: int | None) -> list[dict[str, str]]:
+    if limit is not None:
+        dataset = dataset.select(range(min(limit, len(dataset))))
+    examples: list[dict[str, str]] = []
+    for item in dataset:
+        problem = (item.get("problem") or "").strip()
+        solution = item.get("solution") or ""
+        if isinstance(solution, list):
+            solution = "\n".join(str(part) for part in solution)
+        examples.append(
+            {
+                "problem": problem,
+                "solution": solution,
+            }
+        )
+    return examples
+
+
+def write_jsonl(path: Path, rows: list[dict[str, str]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as fh:
+        for row in rows:
+            fh.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Download MATH dataset splits to JSONL for offline use"
+    )
+    parser.add_argument(
+        "--output-dir", default="examples/rl/data", help="Directory to write <split>.jsonl files"
+    )
+    parser.add_argument(
+        "--dataset",
+        default="nlile/hendrycks-MATH-benchmark",
+        help="Hugging Face dataset identifier",
+    )
+    parser.add_argument(
+        "--config", default="algebra", help="Hugging Face dataset config (if required)"
+    )
+    parser.add_argument(
+        "--splits", nargs="*", default=["train", "validation", "test"], help="Splits to download"
+    )
+    parser.add_argument(
+        "--limit", type=int, default=None, help="Optional cap on examples per split"
+    )
+    args = parser.parse_args()
+
+    output_dir = Path(args.output_dir).expanduser()
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    for split in args.splits:
+        print(f"[INFO] Downloading {args.dataset} ({args.config}) split={split}")
+        if args.config:
+            dataset = load_dataset(args.dataset, args.config, split=split)
+        else:
+            dataset = load_dataset(args.dataset, split=split)
+        rows = extract_examples(dataset, limit=args.limit)
+        out_path = output_dir / f"{split}.jsonl"
+        write_jsonl(out_path, rows)
+        print(f"[INFO] Wrote {len(rows)} examples to {out_path}")
+
+    print("Done. Set MATH_DATASET_LOCAL_DIR to the output directory when serving the task app.")
+
+
+if __name__ == "__main__":
+    main()

synth_ai/__init__.py

@@ -45,13 +45,13 @@ except Exception:
 
 # Judge API contract schemas
 from synth_ai.judge_schemas import (
+    CriterionScorePayload,
+    JudgeOptions,
     JudgeScoreRequest,
     JudgeScoreResponse,
-    JudgeOptions,
     JudgeTaskApp,
     JudgeTracePayload,
     ReviewPayload,
-    CriterionScorePayload,
 )
 
 # Legacy tracing v1 is not required for v3 usage and can be unavailable in minimal envs.

synth_ai/api/models/supported.py

@@ -36,6 +36,7 @@ QWEN3_CODER_MODELS: list[str] = [
 # Training support sets
 RL_SUPPORTED_MODELS: frozenset[str] = frozenset(
     {
+        "Qwen/Qwen3-0.6B",
         "Qwen/Qwen3-1.7B",
         "Qwen/Qwen3-4B",
         "Qwen/Qwen3-4B-Thinking-2507",

synth_ai/api/train/builders.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import importlib
+from collections.abc import Callable
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, cast
@@ -9,25 +10,36 @@ import click
 from pydantic import ValidationError
 
 try:
-    _models_module = importlib.import_module("synth_ai.api.models.supported")
-    UnsupportedModelError = _models_module.UnsupportedModelError
-    ensure_allowed_model = _models_module.ensure_allowed_model
-    normalize_model_identifier = _models_module.normalize_model_identifier
+    _models_module = cast(
+        Any, importlib.import_module("synth_ai.api.models.supported")
+    )
+    UnsupportedModelError = cast(type[Exception], _models_module.UnsupportedModelError)
+    ensure_allowed_model = cast(
+        Callable[..., None], _models_module.ensure_allowed_model
+    )
+    normalize_model_identifier = cast(
+        Callable[[str], str], _models_module.normalize_model_identifier
+    )
 except Exception as exc:  # pragma: no cover - critical dependency
     raise RuntimeError("Unable to load supported model helpers") from exc
 
 try:
-    prepare_sft_job_payload = importlib.import_module("synth_ai.learning.sft.config").prepare_sft_job_payload
+    _sft_module = cast(
+        Any, importlib.import_module("synth_ai.learning.sft.config")
+    )
+    prepare_sft_job_payload = cast(
+        Callable[..., dict[str, Any]], _sft_module.prepare_sft_job_payload
+    )
 except Exception as exc:  # pragma: no cover - critical dependency
     raise RuntimeError("Unable to load SFT payload helpers") from exc
 
+from .configs import RLConfig, SFTConfig
 from .supported_algos import (
     AlgorithmValidationError,
     ensure_model_supported_for_algorithm,
     validate_algorithm_config,
 )
 from .utils import TrainError, ensure_api_base
-from .configs import RLConfig, SFTConfig
 
 
 @dataclass(slots=True)
@@ -125,7 +137,7 @@ def build_rl_payload(
         if model_source:
             model_source = normalize_model_identifier(model_source)
         if model_base:
-            model_base = normalize_model_identifier(model_base, allow_finetuned_prefixes=False)
+            model_base = normalize_model_identifier(model_base)
     except UnsupportedModelError as exc:
         raise click.ClickException(str(exc)) from exc
 
@@ -304,10 +316,12 @@ def build_sft_payload(
         )
     except UnsupportedModelError as exc:
         raise TrainError(str(exc)) from exc
-    try:
-        ensure_model_supported_for_algorithm(base_model, spec)
-    except AlgorithmValidationError as exc:
-        raise TrainError(str(exc)) from exc
+    
+    if base_model:
+        try:
+            ensure_model_supported_for_algorithm(base_model, spec)
+        except AlgorithmValidationError as exc:
+            raise TrainError(str(exc)) from exc
 
     try:
         payload = prepare_sft_job_payload(

synth_ai/api/train/cli.py

@@ -2,15 +2,17 @@ from __future__ import annotations
 
 import importlib
 import os
-from collections.abc import Mapping
+from collections.abc import Callable, Mapping
 from pathlib import Path
-from typing import Any
+from typing import Any, cast
 
 import click
 
 try:
-    _config_module = importlib.import_module("synth_ai.config.base_url")
-    get_backend_from_env = _config_module.get_backend_from_env
+    _config_module = cast(
+        Any, importlib.import_module("synth_ai.config.base_url")
+    )
+    get_backend_from_env = cast(Callable[[], str], _config_module.get_backend_from_env)
 except Exception as exc:  # pragma: no cover - critical dependency
     raise RuntimeError("Unable to load backend configuration helpers") from exc
 
@@ -238,8 +240,12 @@ def train_command(
     ]
     if missing_keys:
         try:
-            _task_apps_module = importlib.import_module("synth_ai.cli.task_apps")
-            _interactive_fill_env = _task_apps_module._interactive_fill_env
+            _task_apps_module = cast(
+                Any, importlib.import_module("synth_ai.cli.task_apps")
+            )
+            _interactive_fill_env = cast(
+                Callable[[Path], Path | None], _task_apps_module._interactive_fill_env
+            )
         except Exception as exc:  # pragma: no cover - protective fallback
             raise click.ClickException(f"Unable to prompt for env values: {exc}") from exc
 

synth_ai/api/train/configs/__init__.py

@@ -1,15 +1,5 @@
 """Typed training config loaders for RL and SFT jobs."""
 
-from .shared import AlgorithmConfig, ComputeConfig
-from .sft import (
-    HyperparametersConfig,
-    HyperparametersParallelism,
-    JobConfig,
-    SFTConfig,
-    SFTDataConfig,
-    TrainingConfig,
-    TrainingValidationConfig,
-)
 from .rl import (
     EvaluationConfig,
     JudgeConfig,
@@ -21,6 +11,16 @@ from .rl import (
     RolloutConfig,
     WeightSyncConfig,
 )
+from .sft import (
+    HyperparametersConfig,
+    HyperparametersParallelism,
+    JobConfig,
+    SFTConfig,
+    SFTDataConfig,
+    TrainingConfig,
+    TrainingValidationConfig,
+)
+from .shared import AlgorithmConfig, ComputeConfig
 
 __all__ = [
     "AlgorithmConfig",

synth_ai/api/train/configs/rl.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+from collections.abc import Mapping
 from pathlib import Path
-from typing import Any, Mapping
+from typing import Any
 
 from pydantic import model_validator
 
@@ -21,7 +22,7 @@ class ModelConfig(ExtraModel):
     label: str
 
     @model_validator(mode="after")
-    def _ensure_exactly_one_source_or_base(self) -> "ModelConfig":
+    def _ensure_exactly_one_source_or_base(self) -> ModelConfig:
         if bool(self.source) == bool(self.base):
             raise ValueError("Config must set exactly one of [model].source or [model].base")
         return self
@@ -111,11 +112,11 @@ class RLConfig(ExtraModel):
         return self.model_dump(mode="python", exclude_none=True)
 
     @classmethod
-    def from_mapping(cls, data: Mapping[str, Any]) -> "RLConfig":
+    def from_mapping(cls, data: Mapping[str, Any]) -> RLConfig:
         return cls.model_validate(dict(data))
 
     @classmethod
-    def from_path(cls, path: Path) -> "RLConfig":
+    def from_path(cls, path: Path) -> RLConfig:
         content = load_toml(path)
         return cls.from_mapping(content)
 

synth_ai/api/train/configs/sft.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+from collections.abc import Mapping
 from pathlib import Path
-from typing import Any, Mapping
+from typing import Any
 
 from pydantic import Field
 
@@ -74,11 +75,11 @@ class SFTConfig(ExtraModel):
         return self.model_dump(mode="python", exclude_none=True)
 
     @classmethod
-    def from_mapping(cls, data: Mapping[str, Any]) -> "SFTConfig":
+    def from_mapping(cls, data: Mapping[str, Any]) -> SFTConfig:
         return cls.model_validate(dict(data))
 
     @classmethod
-    def from_path(cls, path: Path) -> "SFTConfig":
+    def from_path(cls, path: Path) -> SFTConfig:
         content = load_toml(path)
         return cls.from_mapping(content)
 

synth_ai/api/train/env_resolver.py

@@ -5,6 +5,7 @@ import os
 from collections.abc import Callable, Iterable, MutableMapping
 from dataclasses import dataclass
 from pathlib import Path
+from typing import Any, cast
 
 import click
 
@@ -14,8 +15,10 @@ from .utils import REPO_ROOT, mask_value, read_env_file, write_env_value
 
 def _load_saved_env_path() -> Path | None:
     try:
-        module = importlib.import_module("synth_ai.demos.demo_task_apps.core")
-        loader = module.load_env_file_path
+        module = cast(
+            Any, importlib.import_module("synth_ai.demos.demo_task_apps.core")
+        )
+        loader = cast(Callable[[], str | None], module.load_env_file_path)
         saved_path = loader()
         if saved_path:
             return Path(saved_path)

synth_ai/api/train/supported_algos.py

@@ -1,14 +1,19 @@
 from __future__ import annotations
 
 import importlib
-from collections.abc import Mapping
+from collections.abc import Callable, Mapping
 from dataclasses import dataclass
+from typing import Any, cast
 
 try:
-    _models_module = importlib.import_module("synth_ai.api.models.supported")
-    RL_SUPPORTED_MODELS = _models_module.RL_SUPPORTED_MODELS
-    SFT_SUPPORTED_MODELS = _models_module.SFT_SUPPORTED_MODELS
-    training_modes_for_model = _models_module.training_modes_for_model
+    _models_module = cast(
+        Any, importlib.import_module("synth_ai.api.models.supported")
+    )
+    RL_SUPPORTED_MODELS = cast(tuple[str, ...], _models_module.RL_SUPPORTED_MODELS)
+    SFT_SUPPORTED_MODELS = cast(tuple[str, ...], _models_module.SFT_SUPPORTED_MODELS)
+    training_modes_for_model = cast(
+        Callable[[str], tuple[str, ...]], _models_module.training_modes_for_model
+    )
 except Exception as exc:  # pragma: no cover - critical dependency
     raise RuntimeError("Unable to load supported model metadata") from exc
 

synth_ai/api/train/utils.py

@@ -8,15 +8,18 @@ import subprocess
 import tempfile
 import time
 import tomllib
-from collections.abc import Iterable, Mapping
+from collections.abc import Callable, Iterable, Mapping
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any
+from typing import Any, cast
 
 import requests
 
 try:
-    collect_sft_jsonl_errors = importlib.import_module("synth_ai.learning.sft").collect_sft_jsonl_errors
+    sft_module = cast(Any, importlib.import_module("synth_ai.learning.sft"))
+    collect_sft_jsonl_errors = cast(
+        Callable[..., list[dict[str, Any]]], sft_module.collect_sft_jsonl_errors
+    )
 except Exception as exc:  # pragma: no cover - critical dependency
     raise RuntimeError("Unable to load SFT JSONL helpers") from exc
 
@@ -154,7 +157,7 @@ def validate_sft_jsonl(path: Path, *, max_errors: int = 20) -> None:
 
     truncated = max_errors is not None and len(issues) >= max_errors
     suffix = "" if not truncated else f" (showing first {max_errors} issues)"
-    details = "\n - ".join(issues)
+    details = "\n - ".join(cast("list[str]", issues))
     raise TrainError(f"{path}: Dataset validation failed{suffix}:\n - {details}")
 
 

synth_ai/cli/__init__.py

@@ -8,6 +8,8 @@ pyproject entry point `synth_ai.cli:cli`.
 from __future__ import annotations
 
 import importlib
+from collections.abc import Callable
+from typing import Any, cast
 
 # Load environment variables from a local .env if present (repo root)
 try:
@@ -20,98 +22,85 @@ except Exception:
     pass
 
 try:
-    from ._typer_patch import patch_typer_make_metavar
+    from synth_ai.cli._typer_patch import patch_typer_make_metavar
 
     patch_typer_make_metavar()
 except Exception:
     pass
 
 
-from .root import cli  # new canonical CLI entrypoint
+from synth_ai.cli.root import cli  # new canonical CLI entrypoint
 
 # Register subcommands from this package onto the group
+# Deprecated/legacy commands intentionally not registered: watch/experiments, balance, calc,
+# man, recent, status, traces
 try:
-    from . import watch as _watch
+    from synth_ai.cli import demo as _demo
 
-    _watch.register(cli)
+    _demo.register(cli)
 except Exception:
     pass
 try:
-    from . import balance as _balance
+    from synth_ai.cli import turso as _turso
 
-    _balance.register(cli)
+    _turso.register(cli)
 except Exception:
     pass
 try:
-    from . import man as _man
-
-    _man.register(cli)
+    _train_module = cast(Any, importlib.import_module("synth_ai.api.train"))
+    _train_register = cast(Callable[[Any], None], _train_module.register)
+    _train_register(cli)
 except Exception:
     pass
-try:
-    from . import traces as _traces
 
-    _traces.register(cli)
-except Exception:
-    pass
-try:
-    from . import recent as _recent
 
-    _recent.register(cli)
-except Exception:
-    pass
+# Import task_app_group conditionally
 try:
-    from . import calc as _calc
-
-    _calc.register(cli)
+    from synth_ai.cli.task_apps import task_app_group
+    cli.add_command(task_app_group, name="task-app")
 except Exception:
+    # Task app functionality not available
     pass
-try:
-    from . import status as _status
 
-    _status.register(cli)
-except Exception:
-    pass
-try:
-    from . import demo as _demo
 
-    _demo.register(cli)
-except Exception:
-    pass
 try:
-    from . import turso as _turso
-
-    _turso.register(cli)
-except Exception:
+    # Make task_apps import more robust to handle missing optional dependencies
+    import importlib
+    task_apps_module = importlib.import_module('synth_ai.cli.task_apps')
+    task_apps_module.register(cli)
+except (ImportError, ModuleNotFoundError, TypeError, RuntimeError) as e:
+    # Task apps module not available (missing optional dependencies)
+    # This is expected - silently skip
     pass
-try:
-    from . import rl_demo as _rl_demo
 
-    _rl_demo.register(cli)
-except Exception:
-    pass
+# Register TUI command - make import completely isolated
+def _register_tui_command():
+    """Register TUI command only when called, not during CLI startup."""
+    try:
+        # Import TUI only when the command is actually used
+        from synth_ai.cli.tui import register as tui_register
+        tui_register(cli)
+    except Exception:
+        # TUI not available - this is expected if dependencies are missing
+        pass
+
+# Add TUI command as a lazy-registered command
 try:
-    _train_module = importlib.import_module("synth_ai.api.train")
-    _train_register = _train_module.register
-    _train_register(cli)
+    # Try to import and register immediately for normal cases
+    from synth_ai.cli.tui import register as tui_register
+    tui_register(cli)
 except Exception:
+    # If that fails, add a lazy registration that will only happen when called
+    # For now, just skip - the command won't be available but CLI won't crash
     pass
 
-
-from .task_apps import task_app_group
-
-cli.add_command(task_app_group, name="task-app")
-
-
+# Add task app commands if available
 try:
-    from . import task_apps as _task_apps
-
-    _task_apps.register(cli)
+    if 'task_app_group' in locals() and hasattr(task_app_group, 'commands'):
+        cli.add_command(task_app_group.commands["serve"], name="serve")
+        cli.add_command(task_app_group.commands["deploy"], name="deploy")
+        cli.add_command(task_app_group.commands["modal-serve"], name="modal-serve")
 except Exception:
+    # Task app commands not available
     pass
-
-cli.add_command(task_app_group.commands["serve"], name="serve")
-cli.add_command(task_app_group.commands["deploy"], name="deploy")
-
-cli.add_command(task_app_group.commands["modal-serve"], name="modal-serve")
-cli.add_command(task_app_group.commands["info"], name="info")
+# Top-level 'info' alias removed; use `synth-ai task-app info` instead

synth_ai/cli/_modal_wrapper.py

@@ -6,7 +6,7 @@ import sys
 def main() -> int:
     # Apply Typer compatibility patch before Modal CLI bootstraps Click/Typer internals.
     try:
-        from ._typer_patch import patch_typer_make_metavar
+        from synth_ai.cli._typer_patch import patch_typer_make_metavar
 
         patch_typer_make_metavar()
     except Exception:
@@ -20,7 +20,8 @@ def main() -> int:
     else:
         sys.argv = ["modal"]
 
-    return modal_main()
+    result = modal_main()
+    return result if result is not None else 0
 
 
 if __name__ == "__main__":

synth_ai/cli/_storage.py

@@ -8,12 +8,13 @@ allowing type checkers to resolve the symbols dynamically.
 from __future__ import annotations
 
 import importlib
-from typing import Any
+from collections.abc import Callable
+from typing import Any, cast
 
 
 def load_storage() -> tuple[Any, Any]:
     """Return (create_storage, StorageConfig) from tracing_v3.storage."""
-    storage_module = importlib.import_module("synth_ai.tracing_v3.storage")
-    create_storage = storage_module.create_storage
+    storage_module = cast(Any, importlib.import_module("synth_ai.tracing_v3.storage"))
+    create_storage = cast(Callable[..., Any], storage_module.create_storage)
     storage_config = storage_module.StorageConfig
     return create_storage, storage_config