freesolo-flash-dev 0.2.41__tar.gz → 0.2.42__tar.gz

{freesolo_flash_dev-0.2.41 → freesolo_flash_dev-0.2.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freesolo-flash-dev
-Version: 0.2.41
+Version: 0.2.42
 Summary: Flash — managed LoRA post-training (SFT/GRPO) for Freesolo environments, driven by the `flash` CLI
 Project-URL: Homepage, https://github.com/freesolo-co/flash
 Project-URL: Repository, https://github.com/freesolo-co/flash

{freesolo_flash_dev-0.2.41 → freesolo_flash_dev-0.2.42}/flash/cli/__init__.py

@@ -249,7 +249,31 @@ def _build_parser() -> argparse.ArgumentParser:
         const="multi",
         help="scaffold a multi-turn environment (bounded episode with step_episode / score_episode).",
     )
-    setup.set_defaults(func=cmd_env_setup, turn_mode="single")
+    setup_reason = setup.add_mutually_exclusive_group()
+    setup_reason.add_argument(
+        "--reasoning",
+        dest="reasoning",
+        action="store_const",
+        const=True,
+        help="scaffold configs with reasoning enabled (thinking = true, with a raised token budget).",
+    )
+    setup_reason.add_argument(
+        "--no-reasoning",
+        dest="reasoning",
+        action="store_const",
+        const=False,
+        help="scaffold configs without reasoning. This is the default.",
+    )
+    setup.add_argument(
+        "-y",
+        "--yes",
+        dest="yes",
+        action="store_true",
+        help="accept defaults without prompting (single-turn, no reasoning).",
+    )
+    # turn_mode / reasoning default to None (unset) so the scaffold can tell an explicit flag
+    # apart from "not chosen yet" and, on an interactive terminal, ask instead of assuming.
+    setup.set_defaults(func=cmd_env_setup, turn_mode=None, reasoning=None, yes=False)
 
     env_list = env_sub.add_parser("list", help="list local environment sources")
     env_list.set_defaults(func=cmd_env_list)

{freesolo_flash_dev-0.2.41 → freesolo_flash_dev-0.2.42}/flash/cli/commands.py

@@ -330,14 +330,40 @@ _STARTER_DATASET_MULTITURN_JSONL = """\
 """
 
 
+_TURN_OPTIONS = [
+    ("single", "single-turn", "one prompt -> one response"),
+    ("multi", "multi-turn", "bounded episode: step_episode / score_episode"),
+]
+_REASONING_OPTIONS = [
+    ("off", "no reasoning", "the model answers directly"),
+    ("on", "reasoning", "thinking = true; spends more tokens per answer"),
+]
+
+
+def _setup_interactive(args) -> bool:
+    """Whether to ask the setup questions interactively.
+
+    Prompt only on a real terminal a human can answer from. Fall back to defaults (no prompt) when
+    --yes is passed, under CI, or when stdin is closed/redirected, so automation never blocks on an
+    unanswered prompt. A pseudo-TTY in CI can report isatty()=True, so CI is checked explicitly; a
+    closed fd 0 can make sys.stdin None, so that is guarded before .isatty()."""
+    if getattr(args, "yes", False):
+        return False
+    if os.environ.get("CI", "").strip().lower() not in ("", "0", "false", "no"):
+        return False
+    stdin = sys.stdin
+    if stdin is None or not stdin.isatty():
+        return False
+    return render.styled()
+
+
 def cmd_env_setup(args) -> int:
-    requested_multi = getattr(args, "turn_mode", "single") == "multi"
     starter_env = Path("environment.py")
     dataset = Path("dataset/train.jsonl")
     # An existing environment.py is the authoritative signal for which turn mode this
     # scaffold already uses (the dataset is plain JSONL with no reliable mode marker).
     # Anchor to it so a re-run never leaves a single-turn env beside a multi-turn
-    # dataset (or vice versa); the flag only decides the mode when starting fresh.
+    # dataset (or vice versa); the flag/answer only decides the mode when starting fresh.
     existing_multi: bool | None = None
     anchor = "environment.py"
     if starter_env.exists():
@@ -347,15 +373,59 @@ def cmd_env_setup(args) -> int:
         # distinctive prompt; use it so we don't drop a single-turn env beside it.
         existing_multi = "secret whole number" in dataset.read_text(encoding="utf-8")
         anchor = "dataset/train.jsonl"
-    if existing_multi is not None and existing_multi != requested_multi:
-        have = "multi-turn" if existing_multi else "single-turn"
-        want = "multi-turn" if requested_multi else "single-turn"
-        msg = (
-            f"existing {anchor} is {have}; keeping it and ignoring --{want}. "
-            f"Delete environment.py and dataset/train.jsonl first to re-scaffold as {want}."
+
+    # Resolve the turn mode. An existing scaffold wins (warn if a flag disagrees); otherwise an
+    # explicit --single-turn/--multi-turn flag wins; otherwise ask on a terminal, else single-turn.
+    flag_mode = getattr(args, "turn_mode", None)
+    if existing_multi is not None:
+        if flag_mode is not None and (flag_mode == "multi") != existing_multi:
+            have = "multi-turn" if existing_multi else "single-turn"
+            want = "multi-turn" if flag_mode == "multi" else "single-turn"
+            msg = (
+                f"existing {anchor} is {have}; keeping it and ignoring --{want}. "
+                f"Delete environment.py and dataset/train.jsonl first to re-scaffold as {want}."
+            )
+            print(render.warn(msg) if render.styled() else f"warning: {msg}", file=sys.stderr)
+        multi_turn = existing_multi
+    elif flag_mode is not None:
+        multi_turn = flag_mode == "multi"
+    elif _setup_interactive(args):
+        multi_turn = (
+            render.select("How does the model interact with your task?", _TURN_OPTIONS) == "multi"
         )
-        print(render.warn(msg) if render.styled() else f"warning: {msg}", file=sys.stderr)
-    multi_turn = requested_multi if existing_multi is None else existing_multi
+    else:
+        multi_turn = False
+
+    # Resolve reasoning. Like the turn mode, an existing config is authoritative: configs are only
+    # written when absent, so applying a reasoning flag to an already-scaffolded project would
+    # silently no-op (or write one config with reasoning and leave the other without). Anchor to the
+    # existing config's `thinking` state and warn if a flag disagrees; otherwise the flag wins;
+    # otherwise ask on a terminal; else off.
+    rl = Path("configs/rl.toml")
+    sft = Path("configs/sft.toml")
+    existing_reasoning: bool | None = None
+    for cfg in (rl, sft):
+        if cfg.exists():
+            existing_reasoning = "thinking = true" in cfg.read_text(encoding="utf-8")
+            break
+    flag_reason = getattr(args, "reasoning", None)
+    if existing_reasoning is not None:
+        if flag_reason is not None and flag_reason != existing_reasoning:
+            have = "reasoning" if existing_reasoning else "no reasoning"
+            want = "reasoning" if flag_reason else "no-reasoning"
+            msg = (
+                f"existing configs are {have}; keeping them and ignoring --{want}. "
+                f"Delete configs/rl.toml and configs/sft.toml first to re-scaffold with --{want}."
+            )
+            print(render.warn(msg) if render.styled() else f"warning: {msg}", file=sys.stderr)
+        reasoning = existing_reasoning
+    elif flag_reason is not None:
+        reasoning = flag_reason
+    elif _setup_interactive(args):
+        reasoning = render.select("Train with reasoning (thinking)?", _REASONING_OPTIONS) == "on"
+    else:
+        reasoning = False
+
     env_py = _STARTER_ENV_MULTITURN_PY if multi_turn else _STARTER_ENV_PY
     dataset_jsonl = _STARTER_DATASET_MULTITURN_JSONL if multi_turn else _STARTER_DATASET_JSONL
     Path("configs").mkdir(exist_ok=True)
@@ -373,28 +443,47 @@ def cmd_env_setup(args) -> int:
         'id = ""\n\n'
         '# secrets = ["SERPAPI_API_KEY"]\n\n'
     )
-    rl = Path("configs/rl.toml")
+    # `thinking = true` opts the run into reasoning mode. Reasoning shares the generation budget with
+    # the answer, so GRPO also gets a raised max_tokens. These strings are empty when reasoning is
+    # off, keeping the default scaffold byte-for-byte identical.
+    thinking_line = "thinking = true\n" if reasoning else ""
+    rl_reasoning_train = (
+        "max_tokens = 2048  # reasoning shares this budget with the answer; raised so it isn't truncated\n"
+        if reasoning
+        else ""
+    )
+    sft_reasoning_note = (
+        "# reasoning is on (thinking = true): each gold `output` must contain a <think>...</think>\n"
+        "# block; validate locally with freesolo.datasets.warn_missing_think_tags before a real run.\n"
+        if reasoning
+        else ""
+    )
     if not rl.exists():
         rl.write_text(
             'model = "Qwen/Qwen3.5-4B"\n'
-            'algorithm = "grpo"\n\n'
+            'algorithm = "grpo"\n'
+            f"{thinking_line}"
+            "\n"
             f"{env_comment}"
             "[train]\n"
             "steps = 150\n"
+            f"{rl_reasoning_train}"
             "lora_rank = 32\n"
             "# GPU and HF artifacts are managed automatically by the platform: the GPU is\n"
             "# the cheapest fitting managed class, and artifacts live in a private environment-scoped repo.\n"
         )
-    sft = Path("configs/sft.toml")
     if not sft.exists():
         sft.write_text(
             'model = "Qwen/Qwen3.5-4B"\n'
-            'algorithm = "sft"\n\n'
+            'algorithm = "sft"\n'
+            f"{thinking_line}"
+            "\n"
             f"{env_comment}"
             "[train]\n"
             "epochs = 1\n"
             "max_examples = 2  # rows to train on; the starter dataset has 2 (raise as your dataset grows)\n"
             "lora_rank = 32\n"
+            f"{sft_reasoning_note}"
             "# GPU and HF artifacts are managed automatically by the platform: the GPU is\n"
             "# the cheapest fitting managed class, and artifacts live in a private environment-scoped repo.\n"
         )
@@ -768,7 +857,9 @@ def cmd_deploy(args) -> int:
                 f"OpenAI-compatible base URL: {openai_base} — point clients at this /v1 base, "
                 "not the bare endpoint (which 404s on /chat/completions)."
             )
-            print(render.arrow(url_note) if render.styled() else f"note: {url_note}", file=sys.stderr)
+            print(
+                render.arrow(url_note) if render.styled() else f"note: {url_note}", file=sys.stderr
+            )
     if dep.get("state") != "dry_run":
         state = dep.get("state", "deploying")
         if state == "failed":

{freesolo_flash_dev-0.2.41 → freesolo_flash_dev-0.2.42}/flash/cli/render.py

@@ -273,6 +273,38 @@ def arrow(msg: str) -> str:
     return _safe(f"{_paint(_glyph('→', '->'), _ACCENT2)} {_dim(msg)}")
 
 
+def select(title: str, options: list[tuple[str, str, str]], default: int = 0) -> str:
+    """Themed single-choice prompt; returns the chosen option's value.
+
+    ``options`` is a list of ``(value, label, hint)``. The default option is marked and taken on
+    an empty answer (enter). Reads via ``input()`` so it is easy to drive in tests; the caller
+    decides *when* to prompt (interactive stdin), so this always prompts when called. On EOF the
+    default is returned so a closed stdin never hangs the scaffold."""
+    q = _paint(_glyph("?", "?"), _ACCENT, "1")
+    print(f"{q} {_bold(_safe(title))}")
+    for i, (_value, label, hint) in enumerate(options):
+        num = _paint(f"{i + 1})", _ACCENT2)
+        lab = _bold(label) if i == default else label
+        tail = f"  {_dim(_safe(hint))}" if hint else ""
+        mark = _paint(" (default)", _GREEN) if i == default else ""
+        print(f"  {num} {_safe(lab)}{tail}{mark}")
+    pointer = _paint(_glyph("›", ">"), _ACCENT2)  # noqa: RUF001 (the glyph is the point)
+    for _ in range(5):
+        try:
+            raw = input(f"{pointer} ").strip()
+        except EOFError:
+            print()
+            return options[default][0]
+        if not raw:
+            return options[default][0]
+        if raw.isdigit():
+            idx = int(raw) - 1
+            if 0 <= idx < len(options):
+                return options[idx][0]
+        print(note(f"enter 1-{len(options)}, or press enter for the default"))
+    return options[default][0]
+
+
 def money(value: float, decimals: int = 4) -> str:
     return _paint(f"${value:.{decimals}f}", _TEAL)
 

{freesolo_flash_dev-0.2.41 → freesolo_flash_dev-0.2.42}/flash/providers/_worker.py

@@ -110,12 +110,13 @@ def _effective_worker_env(spec=None) -> dict[str, str]:
 # Chalk is published to PUBLIC PyPI on every version bump (chalk .github/workflows/publish.yml).
 # Pin the exact PUBLIC version so worker + kernel-cache-bake pods install with NO GitHub auth — the
 # chalk repo is INTERNAL, so a git+https default made installs fail wherever GITHUB_TOKEN is absent
-# (bake pod, tokenless workers). freesolo-chalk 0.5.0 = chalk PR #21 fafe167 (standalone, Liger fully
-# replaced, + GRPO op + LoRA grad-gate). Bump DEFAULT_CHALK_VERSION when the merged kernel surface moves.
-DEFAULT_CHALK_VERSION = "0.5.1"
+# (bake pod, tokenless workers). freesolo-chalk 0.5.2 = chalk dev->main sync #44 (standalone, Liger
+# fully replaced; adds arch-TUNED gdn_gated_rmsnorm + lora on sm89/sm90/sm100, MoE grouped-GEMM,
+# serving surface, MiniCPM/Llama kernels). Bump DEFAULT_CHALK_VERSION when the merged kernel surface moves.
+DEFAULT_CHALK_VERSION = "0.5.2"
 DEFAULT_CHALK_SPEC = f"freesolo-chalk=={DEFAULT_CHALK_VERSION}"
 # Provenance only (kernel-cache fingerprint / traceability): the chalk commit this version was cut from.
-LATEST_CHALK_MAIN_SHA = "fafe167158eb3b7c947e7182ea4eddc351e4ca7d"
+LATEST_CHALK_MAIN_SHA = "37b2fb9e1a123ceb902ba6ffc4ed182182c6e7d7"
 
 
 def chalk_extra_pip(spec=None) -> list[str]:

{freesolo_flash_dev-0.2.41 → freesolo_flash_dev-0.2.42}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "freesolo-flash-dev"
-version = "0.2.41"
+version = "0.2.42"
 description = "Flash — managed LoRA post-training (SFT/GRPO) for Freesolo environments, driven by the `flash` CLI"
 readme = "README.md"
 # RunPod Flash supports Python 3.11-3.12 (not 3.13 yet).
@@ -106,7 +106,7 @@ artifacts = ["flash/py.typed"]
 # auto-published by .github/workflows/publish-dev.yml: a push to `dev` whose version isn't yet on
 # PyPI publishes it; pushes that don't change it find it already published and no-op. So cutting a
 # dev-channel release = bump this (and [project].version) and merge to `dev`.
-version = "0.2.41"
+version = "0.2.42"
 
 [tool.pytest.ini_options]
 pythonpath = ["."]

{freesolo_flash_dev-0.2.41 → freesolo_flash_dev-0.2.42}/tests/test_cli_commands.py

@@ -8,6 +8,7 @@ the remaining commands are covered without a server.
 from __future__ import annotations
 
 import io
+import types
 
 import pytest
 
@@ -474,6 +475,108 @@ def test_env_setup_scaffolds_grpo_and_sft_configs(monkeypatch, tmp_path, capsys)
     assert "TRAINING.md" in out
 
 
+def test_env_setup_default_omits_reasoning(monkeypatch, tmp_path) -> None:
+    # Non-interactive (pytest stdin is not a tty) with no flags stays on today's scaffold: no
+    # reasoning knobs land in either config.
+    monkeypatch.chdir(tmp_path)
+    assert _run(["env", "setup"]) == 0
+    rl = (tmp_path / "configs/rl.toml").read_text()
+    sft = (tmp_path / "configs/sft.toml").read_text()
+    assert "thinking = true" not in rl
+    assert "thinking = true" not in sft
+    assert "max_tokens" not in rl
+    assert "EnvironmentSingleTurn" in (tmp_path / "environment.py").read_text()
+
+
+def test_env_setup_reasoning_flag_enables_thinking(monkeypatch, tmp_path) -> None:
+    monkeypatch.chdir(tmp_path)
+    assert _run(["env", "setup", "--reasoning"]) == 0
+    rl = (tmp_path / "configs/rl.toml").read_text()
+    sft = (tmp_path / "configs/sft.toml").read_text()
+    assert "thinking = true" in rl
+    assert "thinking = true" in sft
+    # GRPO raises the generation budget so reasoning does not truncate the answer.
+    assert "max_tokens = 2048" in rl
+    # SFT can't share a token budget it doesn't generate; it gets the gold think-tag guidance instead.
+    assert "warn_missing_think_tags" in sft
+    assert "max_tokens" not in sft
+
+
+def test_env_setup_no_reasoning_flag_is_explicit_off(monkeypatch, tmp_path) -> None:
+    monkeypatch.chdir(tmp_path)
+    assert _run(["env", "setup", "--no-reasoning"]) == 0
+    assert "thinking = true" not in (tmp_path / "configs/rl.toml").read_text()
+
+
+def test_env_setup_multi_turn_flag_scaffolds_multiturn(monkeypatch, tmp_path) -> None:
+    monkeypatch.chdir(tmp_path)
+    assert _run(["env", "setup", "--multi-turn"]) == 0
+    assert "EnvironmentMultiTurn" in (tmp_path / "environment.py").read_text()
+    assert "secret whole number" in (tmp_path / "dataset/train.jsonl").read_text()
+
+
+def test_env_setup_interactive_survey_picks_multi_and_reasoning(monkeypatch, tmp_path) -> None:
+    # A real terminal: the two survey questions are asked and answered "2" (multi-turn) then
+    # "2" (reasoning). FLASH_STYLE forces the themed path; a fake stdin reports a tty; input()
+    # is stubbed so no real keypress is read. CI is cleared so the guard doesn't force defaults.
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.delenv("CI", raising=False)
+    monkeypatch.setenv("FLASH_STYLE", "1")
+    monkeypatch.setattr("sys.stdin", types.SimpleNamespace(isatty=lambda: True))
+    answers = iter(["2", "2"])
+    monkeypatch.setattr("builtins.input", lambda *a, **k: next(answers))
+    assert _run(["env", "setup"]) == 0
+    assert "EnvironmentMultiTurn" in (tmp_path / "environment.py").read_text()
+    rl = (tmp_path / "configs/rl.toml").read_text()
+    assert "thinking = true" in rl
+    assert "max_tokens = 2048" in rl
+
+
+def test_env_setup_interactive_enter_takes_defaults(monkeypatch, tmp_path) -> None:
+    # Pressing enter (empty answer) at both questions selects the marked defaults: single-turn,
+    # no reasoning — identical to the non-interactive scaffold.
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.delenv("CI", raising=False)
+    monkeypatch.setenv("FLASH_STYLE", "1")
+    monkeypatch.setattr("sys.stdin", types.SimpleNamespace(isatty=lambda: True))
+    monkeypatch.setattr("builtins.input", lambda *a, **k: "")
+    assert _run(["env", "setup"]) == 0
+    env_py = (tmp_path / "environment.py").read_text()
+    assert "EnvironmentSingleTurn" in env_py
+    assert "EnvironmentMultiTurn" not in env_py
+    assert "thinking = true" not in (tmp_path / "configs/rl.toml").read_text()
+
+
+def test_env_setup_under_ci_never_prompts(monkeypatch, tmp_path) -> None:
+    # Even with a tty and themed output, CI=true must fall back to defaults instead of blocking on
+    # a prompt. input() raises so a regression (actually prompting) fails loudly.
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("CI", "true")
+    monkeypatch.setenv("FLASH_STYLE", "1")
+    monkeypatch.setattr("sys.stdin", types.SimpleNamespace(isatty=lambda: True))
+
+    def _boom(*a, **k):
+        raise AssertionError("prompted under CI")
+
+    monkeypatch.setattr("builtins.input", _boom)
+    assert _run(["env", "setup"]) == 0
+    assert "EnvironmentSingleTurn" in (tmp_path / "environment.py").read_text()
+    assert "thinking = true" not in (tmp_path / "configs/rl.toml").read_text()
+
+
+def test_env_setup_reasoning_flag_warns_when_configs_exist(monkeypatch, tmp_path, capsys) -> None:
+    # First scaffold (no reasoning), then re-run with --reasoning: the existing configs win and the
+    # command warns instead of silently ignoring the flag or writing mismatched configs.
+    monkeypatch.chdir(tmp_path)
+    assert _run(["env", "setup"]) == 0
+    capsys.readouterr()
+    assert _run(["env", "setup", "--reasoning"]) == 0
+    err = capsys.readouterr().err
+    assert "existing configs are no reasoning" in err
+    assert "ignoring --reasoning" in err
+    assert "thinking = true" not in (tmp_path / "configs/rl.toml").read_text()
+
+
 def test_unknown_run_errors_surface_as_nonzero_exit(monkeypatch, capsys) -> None:
     from flash.client import ApiError
 

{freesolo_flash_dev-0.2.41 → freesolo_flash_dev-0.2.42}/tests/test_flash_worker.py

@@ -166,7 +166,7 @@ def test_chalk_extra_pip_defaults_to_latest_main_without_spec(monkeypatch):
     assert chalk_extra_pip() == [DEFAULT_CHALK_SPEC]
     # public PyPI pin so tokenless bake/worker pods can pip-install (chalk repo is internal)
     assert DEFAULT_CHALK_SPEC.startswith("freesolo-chalk==")
-    assert DEFAULT_CHALK_SPEC == "freesolo-chalk==0.5.1"
+    assert DEFAULT_CHALK_SPEC == "freesolo-chalk==0.5.2"
 
 
 def test_chalk_extra_pip_adds_spec_when_set(monkeypatch):

{freesolo_flash_dev-0.2.41 → freesolo_flash_dev-0.2.42}/uv.lock

@@ -1024,7 +1024,7 @@ wheels = [
 
 [[package]]
 name = "freesolo-flash"
-version = "0.2.39"
+version = "0.2.41"
 source = { editable = "." }
 
 [package.optional-dependencies]