freesolo-flash-dev 0.2.46__tar.gz → 0.2.47__tar.gz

{freesolo_flash_dev-0.2.46 → freesolo_flash_dev-0.2.47}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: freesolo-flash-dev
-Version: 0.2.46
-Summary: Flash — managed LoRA post-training (SFT/GRPO) for Freesolo environments, driven by the `flash` CLI
+Version: 0.2.47
+Summary: Flash — managed LoRA post-training (SFT/GRPO/OPD) 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
 Author: Freesolo

{freesolo_flash_dev-0.2.46 → freesolo_flash_dev-0.2.47}/flash/cli/commands.py

@@ -504,16 +504,15 @@ def cmd_env_setup(args) -> int:
         opd.write_text(
             f"{opd_multiturn_note}"
             'model = "Qwen/Qwen3.5-4B"\n'
-            'algorithm = "opd"   # on-policy distillation from a Fireworks GLM teacher\n\n'
+            'algorithm = "opd"   # on-policy distillation from the managed GLM 5.2 teacher\n\n'
             "# Environment: upload this project folder with\n"
             "# `flash env push --name my-env .`, then paste the returned id below.\n"
-            "# The GLM teacher key is platform-managed — nothing to set up or export.\n"
+            "# The GLM 5.2 teacher and key are platform-managed — nothing to set up or export.\n"
             "[environment]\n"
             'id = ""\n\n'
             "[train]\n"
             "steps = 100                     # opd is step-driven (like GRPO)\n"
             "lora_rank = 32\n"
-            '# teacher_model = "accounts/fireworks/models/glm-5p2"   # Fireworks GLM teacher (default)\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"
         )

{freesolo_flash_dev-0.2.46 → freesolo_flash_dev-0.2.47}/flash/cli/training_doc.py

@@ -377,15 +377,16 @@ SFT is **epoch-driven** (`epochs`); GRPO is **step-driven** (`steps`).
 ## On-policy distillation (`algorithm = "opd"`)
 
 Pick distillation when a much stronger **teacher** model can grade your student's work
-token-by-token. The student samples on-policy (like GRPO), a Fireworks-hosted GLM teacher scores
+token-by-token. The student samples on-policy (like GRPO), the managed GLM 5.2 teacher scores
 each of *its own* completions, and a dense per-token loss teaches the student to match the teacher —
 far more sample-efficient than reward-based RL and with no reward to design. It is **step-driven**
 (`steps`) and produces a LoRA served exactly like SFT.
 
-- **No teacher key to set up.** The Fireworks key for the GLM teacher is platform-managed: the
+- **No teacher key or model override to set up.** The GLM 5.2 teacher and its Fireworks key are platform-managed: the
   service supplies its own key to every opd run, so there is nothing to export or declare — an opd
-  run submits like any other. (Bring-your-own teacher keys are not supported; a `FIREWORKS_API_KEY`
-  in your shell is simply ignored.) The key is never stored in the spec or needed at serving time.
+  run submits like any other. Bring-your-own teacher models and keys are not supported; a
+  `FIREWORKS_API_KEY` in your shell is simply ignored. The key is never stored in the spec or
+  needed at serving time.
 - **The student (Qwen / MiniCPM / Kimi) and the teacher (GLM) have different tokenizers.** Flash
   bridges the vocabulary mismatch with **groupwise reverse-KL** (the collinear-ai *spider* / Tinker
   method): it aligns the two tokenizations by shared decoded-text spans and applies per-span reverse
@@ -413,7 +414,6 @@ id = "your-org/my-env"
 [train]
 steps = 100
 lora_rank = 32
-# teacher_model = "accounts/fireworks/models/glm-5p2"   # Fireworks GLM teacher (default)
 # kl_penalty_coef = 1.0                                 # reverse-KL scale
 ```
 

{freesolo_flash_dev-0.2.46 → freesolo_flash_dev-0.2.47}/flash/cost/analytical.py

@@ -44,11 +44,6 @@ MFU_DECODE = 0.12  # batched vLLM rollout (decode is memory-bandwidth-bound)
 # wall is ceil(completions / slots) waves x latency, not completions x latency.
 REWARD_CONCURRENCY = 16.0
 
-# Teacher scoring is CONCURRENT too: run_opd's primary path fans a step's completions across up to
-# TEACHER_CONCURRENCY Fireworks calls (mirror of opd.py _TEACHER_SCORE_MAX_WORKERS), so the teacher
-# wall is ceil(completions / slots) waves x latency, not completions x latency.
-TEACHER_CONCURRENCY = 8.0
-
 # Cold-start overhead (seconds): container boot + deps + model load (+ vLLM init for GRPO).
 #
 # Calibrated against a real fresh-worker run (0.8B SFT, RTX 3090 @ $0.239/hr) whose elapsed wall
@@ -112,11 +107,12 @@ def seconds_per_step(config: RunConfig, gpu: str) -> float:
         gen_s = (GRPO_GEN_FLOPS_PER_TOKEN_PER_PARAM * params * seq_tokens) / (peak * MFU_DECODE)
         update_s = (OPD_UPDATE_FLOPS_PER_TOKEN_PER_PARAM * params * seq_tokens) / (peak * MFU_TRAIN)
         teacher_lat = teacher_seconds_per_completion()
-        # run_opd's primary path scores a step's completions CONCURRENTLY over Fireworks, bounded by
-        # TEACHER_CONCURRENCY workers (opd.py _TEACHER_SCORE_MAX_WORKERS), so the teacher wall is
-        # ceil(completions / slots) waves x latency — NOT the full serial sum (that describes only the
-        # CPU-test fallback that can't batch-generate). ceil keeps a partial last wave at one latency.
-        teacher_s = math.ceil(completions / TEACHER_CONCURRENCY) * teacher_lat
+        # run_opd's primary path scores a step's completions CONCURRENTLY over Fireworks with a fan-out
+        # cap of the step's OWN completion count (prompts_per_step * group_size, opd.py Phase 2), so
+        # every completion in a step is scored in ONE parallel wave — the teacher wall is a single
+        # latency, NOT the full serial sum (that describes only the CPU-test fallback that can't
+        # batch-generate). The teacher endpoint's rate limit is the real ceiling on this fan-out.
+        teacher_s = teacher_lat if completions else 0.0
         return gen_s + teacher_s + update_s
 
     if not n.is_grpo:

{freesolo_flash_dev-0.2.46 → freesolo_flash_dev-0.2.47}/flash/cost/facts.py

@@ -166,10 +166,9 @@ def reward_seconds_per_completion(override: float | None = None) -> float:
 # NO FIREWORKS_API_KEY. Source: https://fireworks.ai/models/fireworks/glm-5p2 lists
 # $1.40 / $0.14 / $4.40 (input / cached input / output) per 1M. opd echo-scores completions
 # (max_tokens=0), so only INPUT tokens are billed (the teacher never generates) — but the table keeps
-# both so a mispriced entry is obvious. glm-5p1 shares the GLM-5 serverless rate.
+# both so a mispriced entry is obvious.
 TEACHER_USD_PER_1M: dict[str, tuple[float, float]] = {
     "accounts/fireworks/models/glm-5p2": (1.40, 4.40),
-    "accounts/fireworks/models/glm-5p1": (1.40, 4.40),
 }
 # Fireworks echo-scoring round-trip per completion (wall time, concurrency-bound like reward grading).
 AVG_TEACHER_SECONDS_PER_COMPLETION = 2.0
@@ -178,11 +177,9 @@ AVG_TEACHER_SECONDS_PER_COMPLETION = 2.0
 def teacher_price_per_1m(teacher_model: str) -> tuple[float, float]:
     """(input, output) $/1M tokens for a teacher model.
 
-    The empty-string sentinel (an opd run that OMITS [train] teacher_model) resolves to the recipe's
-    default teacher (``RECIPE.opd.teacher_model``) — the SINGLE source of "who is the default
-    teacher" — so the quote uses that model's real rate with no forked default-price constant. An
-    unknown non-default teacher falls back to the default teacher's rate (spec-parse already rejects
-    an unpriced teacher_model, so this is only a defensive backstop)."""
+    OPD uses the recipe's fixed GLM 5.2 teacher. ``teacher_model`` is accepted only for internal
+    diagnostics/tests; user configs cannot override it. Unknown values fall back defensively to
+    the fixed teacher rate."""
     from flash.engine.recipe import RECIPE
 
     default = TEACHER_USD_PER_1M[RECIPE.opd.teacher_model]

{freesolo_flash_dev-0.2.46 → freesolo_flash_dev-0.2.47}/flash/cost/spec.py

@@ -110,9 +110,6 @@ def runconfig_from_spec(spec) -> RunConfig:
         provider="auto",
         max_wall_seconds=g.max_wall_seconds,
         environment=spec.environment.id or None,
-        # "" is the unset sentinel (RunConfig.teacher_model); facts.teacher_price_per_1m resolves it
-        # to the recipe default. Non-opd carries no teacher.
-        teacher_model=t.teacher_model if spec.algorithm == "opd" else "",
     )
 
 

{freesolo_flash_dev-0.2.46 → freesolo_flash_dev-0.2.47}/flash/cost/types.py

@@ -27,9 +27,8 @@ class RunConfig:
     thinking: bool = False
     # GRPO only: seconds to score one completion. None -> the single average grader latency.
     reward_seconds_per_completion: float | None = None
-    # OPD only: the Fireworks teacher id, so the teacher-token quote uses the right per-model rate.
-    # "" (the unset sentinel, matching TrainSpec.teacher_model) resolves to the recipe's default
-    # teacher (RECIPE.opd.teacher_model) at the pricing boundary (facts.teacher_price_per_1m).
+    # OPD only: internal Fireworks teacher id for teacher-token diagnostics. User configs cannot
+    # override this; an empty value resolves to the recipe's fixed GLM 5.2 teacher.
     teacher_model: str = ""
 
     max_wall_seconds: int | None = None  # wall cap (spec gpu.max_wall_seconds); None = 24h

{freesolo_flash_dev-0.2.46 → freesolo_flash_dev-0.2.47}/flash/engine/recipe.py

@@ -50,9 +50,8 @@ class OPDConfig:
     """On-policy distillation: student samples, a remote teacher scores its tokens, and a groupwise
     reverse-KL loss (the collinear-ai spider / Tinker cross-tokenizer method) trains the student."""
 
-    # Fireworks-hosted teacher reached over the OpenAI-compatible API; overridable via
-    # [train].teacher_model. GLM-5.2 is a strong reasoning model whose per-token logprobs
-    # supervise the (much smaller) student.
+    # Fixed Fireworks-hosted GLM 5.2 teacher reached over the OpenAI-compatible API. This is
+    # platform-managed and intentionally not configurable from [train].
     teacher_model: str = "accounts/fireworks/models/glm-5p2"
     teacher_base_url: str = "https://api.fireworks.ai/inference/v1"
     # OPD is step-driven like GRPO (on-policy sampling), not epoch-driven like SFT.

{freesolo_flash_dev-0.2.46 → freesolo_flash_dev-0.2.47}/flash/engine/worker/opd.py

@@ -54,11 +54,6 @@ from flash.engine.worker.perf import (
 from flash.engine.worker.teacher import TeacherError
 from flash.engine.worker.tokenizer_align import groupwise_alignment, groupwise_coverage
 
-# Upper bound on teacher-scoring HTTP calls fired concurrently within one optimizer step. Generation
-# (GPU) and the gkd loss forward/backward stay serial on the main thread; only the (dominant) teacher
-# Fireworks round-trips for a step's samples are overlapped, so this caps the fan-out into the API.
-_TEACHER_SCORE_MAX_WORKERS = 8  # bound concurrent GLM/Fireworks scoring calls per step
-
 
 @dataclass(frozen=True)
 class OpdKnobs:
@@ -108,7 +103,7 @@ def _resolve_opd_knobs() -> OpdKnobs:
             "publishes an untrained adapter. Omit the field to use the default, or set a positive value."
         )
     return OpdKnobs(
-        teacher_model=opt("teacher_model", "") or d.teacher_model,
+        teacher_model=d.teacher_model,
         teacher_base_url=d.teacher_base_url,
         steps=int(opt("steps", 0) or d.num_steps),
         learning_rate=float(opt("learning_rate", 0) or d.learning_rate),
@@ -668,16 +663,20 @@ def run_opd():
                             # Feed the stall clock during the (serial, up-to-~900s-each) generations;
                             # nseq is still 0 here since no loss has landed yet this step.
                             _opd_progress(opt_steps, nseq)
-                # Phase 2 (concurrent, NETWORK only): fire the teacher scoring calls for every scorable
-                # rollout at once, bounded by _TEACHER_SCORE_MAX_WORKERS. _score_one touches only the
-                # stateless teacher HTTP client + Python strings (no torch/model/shared mutable state),
-                # so the round-trips overlap safely; truncated/empty/U+FFFD rollouts are never scored.
+                # Phase 2 (concurrent, NETWORK only): fire the teacher scoring calls for EVERY scorable
+                # rollout at once — the fan-out cap is the step's own completion count
+                # (prompts_per_step * group_size), so every sample in a step is scored in parallel (one
+                # round-trip of wall time) and the concurrency self-scales when group_size is raised
+                # (no queueing 8-at-a-time). The teacher endpoint's own rate limit is the real ceiling;
+                # 429s retry inside _score_one. _score_one touches only the stateless teacher HTTP client
+                # + Python strings (no torch/model/shared mutable state), so the round-trips overlap
+                # safely; truncated/empty/U+FFFD rollouts are never scored.
                 scorable = [i for i, p in enumerate(pending) if not (p.gen.skip or p.gen.truncated)]
                 _opd_progress(opt_steps, nseq)  # refresh entering the (bounded) network phase
                 if scorable:
                     permanent_err = None
                     with ThreadPoolExecutor(
-                        max_workers=min(len(scorable), _TEACHER_SCORE_MAX_WORKERS)
+                        max_workers=min(len(scorable), knobs.prompts_per_step * knobs.group_size)
                     ) as pool:
                         fut_to_idx = {
                             pool.submit(

{freesolo_flash_dev-0.2.46 → freesolo_flash_dev-0.2.47}/flash/schema/__init__.py

@@ -21,7 +21,6 @@ from flash.schema.fields import (
     _train_float,
     _train_int,
     _train_stops,
-    _train_str,
     _wandb_spec,
     _worker_env,
 )
@@ -210,8 +209,6 @@ _TRAIN_KEYS = frozenset(
         "stop_sequences",
         "max_steps",
         "max_examples",
-        # on-policy distillation (algorithm="opd")
-        "teacher_model",
     }
 )
 
@@ -222,7 +219,7 @@ def spec_from_dict(raw: dict[str, Any], run_id: str | None = None) -> JobSpec:
         hint = ""
         if {"grpo", "sft", "opd"} & set(unknown):
             hint = (
-                " — GRPO/SFT/opd knobs (group_size, batch_size, max_tokens, teacher_model, …) "
+                " — GRPO/SFT/opd knobs (group_size, batch_size, max_tokens, …) "
                 "belong under [train], not a [grpo]/[sft]/[opd] table"
             )
         raise ConfigError(
@@ -358,7 +355,6 @@ def spec_from_dict(raw: dict[str, Any], run_id: str | None = None) -> JobSpec:
             # minimum=0: explicit 0 means "no cap" per TrainSpec contract
             max_steps=_train_int(train_raw, "max_steps", minimum=0),
             max_examples=_train_int(train_raw, "max_examples", minimum=0),
-            teacher_model=_train_str(train_raw, "teacher_model"),
         ),
         gpu=GpuSpec(type=gpu_type),
         run_id=run_id or "local",  # server-assigned at create_run; never user-set
@@ -389,24 +385,13 @@ def _validate_grpo(spec: JobSpec) -> None:
 
 
 def _validate_opd(spec: JobSpec) -> None:
-    """OPD contract: step-driven (positive steps), a priced teacher, and a usable prompt budget.
+    """OPD contract: step-driven (positive steps) with a usable prompt budget.
 
     The teacher key (FIREWORKS_API_KEY) is a platform-owned credential the control plane injects into
     the worker env (build_worker_env), like HF_TOKEN — never a user-declared secret."""
     if spec.train.steps is not None and spec.train.steps <= 0:
         # OPD is step-driven (on-policy sampling), like GRPO — not epoch-driven.
         raise ConfigError("train.steps must be positive for opd")
-    if spec.train.teacher_model:
-        # Reject an unpriced teacher override at parse time: falling back to the default rate would
-        # make both the submit-time quote and the final charge wrong for a differently-priced model.
-        from flash.cost.facts import TEACHER_USD_PER_1M
-
-        if spec.train.teacher_model not in TEACHER_USD_PER_1M:
-            raise ConfigError(
-                f"[train] teacher_model {spec.train.teacher_model!r} has no pricing entry, so its "
-                f"cost quote and charge would silently use the default rate. Use a priced teacher "
-                f"({', '.join(sorted(TEACHER_USD_PER_1M))}) or add an entry in flash/cost/facts.py."
-            )
     if spec.train.max_length:
         # Mirror run_opd's prompt-budget guard at PARSE time: a max_length that leaves no room for
         # any prompt after the completion budget is rejected here, BEFORE a paid worker is

{freesolo_flash_dev-0.2.46 → freesolo_flash_dev-0.2.47}/flash/spec.py

@@ -124,8 +124,6 @@ class TrainSpec:
     advantage_clip: float | None = None
     thinking_length_penalty_coef: float | None = None
     stop_sequences: tuple[str, ...] = ()
-    # On-policy distillation (algorithm="opd"). None/"" => worker resolves the recipe default.
-    teacher_model: str = ""
 
 
 @dataclass(frozen=True)
@@ -212,7 +210,6 @@ class JobSpec:
                 advantage_clip=_opt_float(train.get("advantage_clip")),
                 thinking_length_penalty_coef=_opt_float(train.get("thinking_length_penalty_coef")),
                 stop_sequences=_str_tuple(train.get("stop_sequences")),
-                teacher_model=str(train.get("teacher_model") or ""),
             ),
             gpu=GpuSpec(
                 type=gpu.get("type", DEFAULT_GPU),

{freesolo_flash_dev-0.2.46 → freesolo_flash_dev-0.2.47}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "freesolo-flash-dev"
-version = "0.2.46"
-description = "Flash — managed LoRA post-training (SFT/GRPO) for Freesolo environments, driven by the `flash` CLI"
+version = "0.2.47"
+description = "Flash — managed LoRA post-training (SFT/GRPO/OPD) for Freesolo environments, driven by the `flash` CLI"
 readme = "README.md"
 # RunPod Flash supports Python 3.11-3.12 (not 3.13 yet).
 requires-python = ">=3.11,<3.13"
@@ -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.46"
+version = "0.2.47"
 
 [tool.pytest.ini_options]
 pythonpath = ["."]

{freesolo_flash_dev-0.2.46 → freesolo_flash_dev-0.2.47}/tests/test_cost_analytical.py

@@ -272,33 +272,24 @@ def test_nonpositive_run_knobs_rejected(knob, bad):
         RunConfig(MID, "grpo", 100, **{knob: bad})
 
 
-def test_opd_teacher_scoring_is_billed_in_concurrency_waves_not_serially():
-    # Teacher scoring runs CONCURRENTLY in run_opd (up to TEACHER_CONCURRENCY Fireworks calls per
-    # step), so a step's teacher wall is ceil(completions / slots) waves x latency, NOT the full
-    # serial sum. Isolate the teacher term by holding seq_tokens (hence gen_s/update_s) constant while
-    # doubling completions across a wave boundary: TEACHER_CONCURRENCY completions = 1 wave, 2x = 2
-    # waves, so the per-step delta is exactly ONE teacher latency -- not the ~8x a serial
-    # (completions x latency) model would add.
-    from flash.cost.analytical import TEACHER_CONCURRENCY, seconds_per_step
+def test_opd_teacher_scoring_is_one_parallel_wave():
+    # Teacher scoring fans a step's completions across prompts_per_step*group_size concurrent Fireworks
+    # calls (opd.py Phase 2), so EVERY completion in a step is scored in one parallel wave -- the
+    # teacher wall is a single latency regardless of completion count, NOT the serial (completions x
+    # latency) sum. Hold seq_tokens (hence gen_s/update_s) constant while doubling the completion count;
+    # since scoring is now fully parallel the teacher term is unchanged, so the per-step delta is 0.
+    from flash.cost.analytical import seconds_per_step
     from flash.cost.facts import teacher_seconds_per_completion
 
     gpu = "RTX 5090"
     teacher_lat = teacher_seconds_per_completion()
-    assert teacher_lat > 0  # else the assertion below is vacuous
-    slots = int(TEACHER_CONCURRENCY)
-    # completions x seq_len is identical (slots*2048 == 2*slots*1024), so only the wave count differs.
-    one_wave = RunConfig(MID, "opd", 10, batch_size=slots, group_size=1, seq_len=2048)
-    two_waves = RunConfig(MID, "opd", 10, batch_size=slots * 2, group_size=1, seq_len=1024)
-    delta = seconds_per_step(two_waves, gpu) - seconds_per_step(one_wave, gpu)
-    assert delta == pytest.approx(teacher_lat), (
-        "crossing one concurrency wave must add exactly one teacher latency, not one per completion"
+    assert teacher_lat > 0  # else the isolation below is vacuous
+    # completions x seq_len is identical (8*2048 == 16*1024), so gen_s/update_s match and only the
+    # completion count (hence any wave scaling) differs.
+    few = RunConfig(MID, "opd", 10, batch_size=8, group_size=1, seq_len=2048)
+    many = RunConfig(MID, "opd", 10, batch_size=16, group_size=1, seq_len=1024)
+    delta = seconds_per_step(many, gpu) - seconds_per_step(few, gpu)
+    assert delta == pytest.approx(0.0, abs=1e-6), (
+        "full-parallel teacher scoring bills one wave; doubling completions at equal total tokens "
+        "must not add teacher latency"
     )
-
-
-def test_opd_teacher_concurrency_matches_worker_pool():
-    # The cost model's TEACHER_CONCURRENCY must track the worker's actual pool size, or quotes drift
-    # from real runs. Guard the two constants against silent divergence.
-    from flash.cost.analytical import TEACHER_CONCURRENCY
-    from flash.engine.worker.opd import _TEACHER_SCORE_MAX_WORKERS
-
-    assert TEACHER_CONCURRENCY == _TEACHER_SCORE_MAX_WORKERS

{freesolo_flash_dev-0.2.46 → freesolo_flash_dev-0.2.47}/tests/test_opd.py

@@ -416,24 +416,23 @@ def test_opd_vram_sizing_uses_completion_budget_not_sft_default():
     assert opd_rollout_seq_len(4096, 8192, False) == 4096  # explicit max_length pins the sequence
 
 
-def test_opd_rejects_unpriced_teacher_model_but_accepts_priced():
+def test_opd_rejects_teacher_model_override():
     from flash.schema import ConfigError, spec_from_dict
 
-    def _spec(teacher):
-        return spec_from_dict(
+    with pytest.raises(ConfigError, match="teacher_model"):
+        spec_from_dict(
             {
                 "model": "Qwen/Qwen3.5-4B",
                 "algorithm": "opd",
                 "environment": {"id": "github:owner/repo@main:env/environment.py"},
-                "train": {"steps": 5, "hf_repo": "owner/runs", "teacher_model": teacher},
+                "train": {
+                    "steps": 5,
+                    "teacher_model": "accounts/fireworks/models/glm-5p2",
+                },
             },
             run_id="x",
         )
 
-    _spec("accounts/fireworks/models/glm-5p2")  # priced -> ok
-    with pytest.raises(ConfigError):
-        _spec("accounts/fireworks/models/mystery-9000")  # unpriced override -> reject at parse
-
 
 def test_opd_rejects_prompt_budget_at_parse_time_before_provisioning():
     """max_length <= max_tokens leaves no prompt budget; opd must reject it at spec-parse time
@@ -2607,7 +2606,6 @@ def test_opd_spec_json_round_trip():
             "environment": {"id": "github:owner/repo@main:env/environment.py"},
             "train": {
                 "steps": 25,
-                "teacher_model": "accounts/fireworks/models/glm-5p1",
                 "hf_repo": "owner/runs",
             },
         },
@@ -2616,7 +2614,6 @@ def test_opd_spec_json_round_trip():
     restored = JobSpec.from_json(spec.to_json())
     assert restored == spec
     assert restored.phase == "opd"
-    assert restored.train.teacher_model == "accounts/fireworks/models/glm-5p1"
     # The teacher key is platform-managed (control-plane-injected into the worker env, like
     # HF_TOKEN) — NOT a user secret, so it is never added to environment.secrets.
     assert "FIREWORKS_API_KEY" not in restored.environment.secrets

{freesolo_flash_dev-0.2.46 → freesolo_flash_dev-0.2.47}/uv.lock

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