freesolo-flash-dev 1.4.6__tar.gz → 1.4.8__tar.gz

{freesolo_flash_dev-1.4.6 → freesolo_flash_dev-1.4.8}/.github/workflows/publish-dev.yml

@@ -19,6 +19,7 @@ on:
       - "uv.lock"
       - "flash/**"
       - "scripts/build_dev_dist.py"
+      - "scripts/check_dev_release.py"
       - ".github/workflows/publish-dev.yml"
   workflow_dispatch:
 
@@ -82,24 +83,7 @@ jobs:
         id: decide
         env:
           VERSION: ${{ steps.meta.outputs.version }}
-        run: |
-          python3 - <<'PY' >> "$GITHUB_OUTPUT"
-          import os
-          import urllib.error
-          import urllib.request
-
-          version = os.environ["VERSION"]
-          url = f"https://pypi.org/pypi/freesolo-flash-dev/{version}/json"
-          published = False
-          try:
-              with urllib.request.urlopen(url, timeout=30) as response:
-                  published = response.status == 200
-          except urllib.error.HTTPError as error:
-              if error.code != 404:
-                  raise
-          # Publish only when the dev version isn't on PyPI yet (i.e. it was just bumped).
-          print(f"publish={'false' if published else 'true'}")
-          PY
+        run: python3 scripts/check_dev_release.py >> "$GITHUB_OUTPUT"
 
       - name: Already published (nothing to do)
         if: steps.decide.outputs.publish == 'false'

{freesolo_flash_dev-1.4.6 → freesolo_flash_dev-1.4.8}/CHANGELOG.md

@@ -162,6 +162,12 @@ This file starts at 1.1.35. Earlier releases are not reconstructed here; use
 
 ### Fixed
 
+- API-key verification bridges brief Freesolo identity-service outages. A key that verified
+  successfully within the last 5 minutes is accepted when verification is unavailable (transport
+  errors or 5xx), instead of failing the request with `503 Authentication service unavailable`.
+  Live verification still runs on every request while the service answers, and a definitive
+  rejection forgets the key, so revocation stays immediate. Long multi-turn rollouts previously
+  lost about 13% of episodes to these 503s.
 - Image SFT no longer stores processed pixel tensors in the training parquet. The worker keeps
   each row's small processor fields (image grid, token types) and its saved image files, and the
   training dataset rebuilds `pixel_values` per item, checking the stored grid. Before this,

{freesolo_flash_dev-1.4.6 → freesolo_flash_dev-1.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: freesolo-flash-dev
-Version: 1.4.6
+Version: 1.4.8
 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
@@ -144,11 +144,19 @@ path is self-hostable end to end — see **[SELF_HOSTING.md](SELF_HOSTING.md)**.
 
 ## Using the hosted service
 
-The active training catalog is `Qwen/Qwen3.5-9B`, `Qwen/Qwen3.8-27B`, and
-`Qwen/Qwen3.6-35B-A3B`. The hosted serving catalog routes all three models on B200.
-The retired dense Qwen3.6 27B identity is never translated into Qwen3.8. Customer-owned
-Modal supports all three active models; 27B and 35B-A3B are bound to the certified serving image
-digest. Customer-owned `flash serve` requires explicit `--provider modal`. Training and serving both use Modal.
+The training catalog includes Qwen3.5 0.8B, 4B, 9B, and **9B Base**, Qwen3.8 27B,
+and Qwen3.6 35B-A3B. `Qwen/Qwen3.5-9B` is Qwen's post-trained chat model and remains
+the default. Select `model = "Qwen/Qwen3.5-9B-Base"` to fine-tune the pretrained-only
+checkpoint with SFT or GRPO. It has its own weights, tokenizer revision, adapters,
+and Modal cache entry; it is never mapped to the post-trained model's FP8 weights.
+Its native chat template supports text, images, and tool calls, but the pretrained
+weights have not been tuned for instruction following.
+
+Hosted serving uses the [per-model GPU placements](flash/serving/app/README.md#hosted-gpu-configuration).
+The 9B Base checkpoint serves in BF16 on H100 with a 262,144-token context.
+Customer-owned `flash serve` requires explicit `--provider modal` and a live-qualified
+profile. The retired dense Qwen3.6 27B identity is never translated into Qwen3.8.
+Training and serving both use Modal.
 
 `flash login` is not interactive. Export `FREESOLO_API_KEY` first so the key does not appear in process listings:
 
@@ -341,6 +349,19 @@ endpoint returns `409` with a hint to deploy first. Prefer this control-plane en
 directly: it enforces run ownership and forwards per-run serving options such as
 thinking-mode parity.
 
+Tool parameters use a restricted JSON Schema profile. Inside JSON arrays and objects,
+scalar types can be combined explicitly, for example `"type": ["string", "number",
+"boolean", "null"]` for spreadsheet cells. Empty schemas (`{}`), container unions,
+and unions on top-level function arguments are unsupported. Top-level arguments use
+native parameter text, where a string such as `"12"` and a number would be ambiguous;
+nested JSON preserves those types during generation, streaming, and history replay.
+
+Qualified Qwen tool-calling routes support thinking-enabled generation. Tool calls are
+parsed only after the first `</think>`; tool-like text inside reasoning stays in
+`reasoning_content`. A response that ends before that boundary cannot execute tools.
+Streaming preserves the same separation, and saved adapters retain their configured
+thinking mode. Tools still cannot be combined with logprobs or structured outputs.
+
 ### Workload estimates (SFT)
 
 `flash train`, `--dry-run`, and `--cost` read the pinned environment's packaged dataset

{freesolo_flash_dev-1.4.6 → freesolo_flash_dev-1.4.8}/README.md

@@ -44,11 +44,19 @@ path is self-hostable end to end — see **[SELF_HOSTING.md](SELF_HOSTING.md)**.
 
 ## Using the hosted service
 
-The active training catalog is `Qwen/Qwen3.5-9B`, `Qwen/Qwen3.8-27B`, and
-`Qwen/Qwen3.6-35B-A3B`. The hosted serving catalog routes all three models on B200.
-The retired dense Qwen3.6 27B identity is never translated into Qwen3.8. Customer-owned
-Modal supports all three active models; 27B and 35B-A3B are bound to the certified serving image
-digest. Customer-owned `flash serve` requires explicit `--provider modal`. Training and serving both use Modal.
+The training catalog includes Qwen3.5 0.8B, 4B, 9B, and **9B Base**, Qwen3.8 27B,
+and Qwen3.6 35B-A3B. `Qwen/Qwen3.5-9B` is Qwen's post-trained chat model and remains
+the default. Select `model = "Qwen/Qwen3.5-9B-Base"` to fine-tune the pretrained-only
+checkpoint with SFT or GRPO. It has its own weights, tokenizer revision, adapters,
+and Modal cache entry; it is never mapped to the post-trained model's FP8 weights.
+Its native chat template supports text, images, and tool calls, but the pretrained
+weights have not been tuned for instruction following.
+
+Hosted serving uses the [per-model GPU placements](flash/serving/app/README.md#hosted-gpu-configuration).
+The 9B Base checkpoint serves in BF16 on H100 with a 262,144-token context.
+Customer-owned `flash serve` requires explicit `--provider modal` and a live-qualified
+profile. The retired dense Qwen3.6 27B identity is never translated into Qwen3.8.
+Training and serving both use Modal.
 
 `flash login` is not interactive. Export `FREESOLO_API_KEY` first so the key does not appear in process listings:
 
@@ -241,6 +249,19 @@ endpoint returns `409` with a hint to deploy first. Prefer this control-plane en
 directly: it enforces run ownership and forwards per-run serving options such as
 thinking-mode parity.
 
+Tool parameters use a restricted JSON Schema profile. Inside JSON arrays and objects,
+scalar types can be combined explicitly, for example `"type": ["string", "number",
+"boolean", "null"]` for spreadsheet cells. Empty schemas (`{}`), container unions,
+and unions on top-level function arguments are unsupported. Top-level arguments use
+native parameter text, where a string such as `"12"` and a number would be ambiguous;
+nested JSON preserves those types during generation, streaming, and history replay.
+
+Qualified Qwen tool-calling routes support thinking-enabled generation. Tool calls are
+parsed only after the first `</think>`; tool-like text inside reasoning stays in
+`reasoning_content`. A response that ends before that boundary cannot execute tools.
+Streaming preserves the same separation, and saved adapters retain their configured
+thinking mode. Tools still cannot be combined with logprobs or structured outputs.
+
 ### Workload estimates (SFT)
 
 `flash train`, `--dry-run`, and `--cost` read the pinned environment's packaged dataset

{freesolo_flash_dev-1.4.6 → freesolo_flash_dev-1.4.8}/flash/cli/scaffold/TRAINING.md

@@ -461,13 +461,10 @@ described above.
 Never derive seconds-per-step from total elapsed time (early steps include one-time warmup
 that can dominate a short run).
 
-> **Even on a genuinely stale heartbeat, do NOT cancel.** Flash **auto-retries a preempted job from its
-> last checkpoint**, and the provider's `job_preempted` notice can lag the freeze by ~10
-> minutes. Cancelling races that retry and kills a run that was recovering on its own.
-> Wait for either the automatic retry or a genuine terminal state. Cancel only when a run
-> is confirmed dead with no retry pending, or is burning money on a definite unrecoverable
-> fault. An idle GPU during model load is also not evidence of a hang — and it is not
-> evidence that your GPU class is unhealthy, so do not "fix" it by pinning another one.
+A stale heartbeat alone does not identify the failure. Check the provider/attempt state and
+wait for a terminal result or a retry decision for a supported failure category. Host preemption
+is terminal: Flash does not automatically restart a preempted job. Preserve any published
+checkpoints for an explicit follow-up run. An idle GPU during model loading can be normal.
 
 ### 6. Deploy & chat
 

freesolo_flash_dev-1.4.8/flash/content/processor.py

@@ -0,0 +1,17 @@
+"""Normalize chat-template metadata from a checkpoint's own processor and tokenizer."""
+
+from typing import Any
+
+
+def inherit_tokenizer_chat_template(processor: Any) -> None:
+    """Support checkpoints that publish their template only in tokenizer_config.json.
+
+    Transformers loads that template onto the tokenizer but not AutoProcessor.
+    Preserve explicit processor templates and never substitute another model's tokenizer.
+    Missing templates remain missing so the normal request validation can reject them.
+    """
+    if getattr(processor, "chat_template", None) is None:
+        tokenizer = getattr(processor, "tokenizer", None)
+        template = getattr(tokenizer, "chat_template", None)
+        if template is not None:
+            processor.chat_template = template

freesolo_flash_dev-1.4.8/flash/content/stop_tokens.py

@@ -0,0 +1,13 @@
+"""Chat-turn boundaries for pretrained checkpoints with document-level EOS metadata."""
+
+from typing import Any
+
+
+def chat_stop_token_ids(model: str, tokenizer: Any, *, is_chat: bool) -> list[int] | None:
+    """Stop Base chat at im_end without changing its tokenizer or raw completion EOS."""
+    if model != "Qwen/Qwen3.5-9B-Base" or not is_chat:
+        return None
+    token_id = tokenizer.convert_tokens_to_ids("<|im_end|>")
+    if type(token_id) is not int or token_id < 0 or token_id == tokenizer.unk_token_id:
+        raise ValueError("Qwen3.5 9B Base tokenizer is missing its chat end token")
+    return [token_id]

{freesolo_flash_dev-1.4.6 → freesolo_flash_dev-1.4.8}/flash/core/catalog.py

@@ -16,6 +16,7 @@ _ON_POLICY_ALGORITHMS = frozenset({"grpo"})
 _IMAGE_TRAINING_MODELS = frozenset(
     {
         "Qwen/Qwen3.5-9B",
+        "Qwen/Qwen3.5-9B-Base",
         "Qwen/Qwen3.8-27B",
         "Qwen/Qwen3.6-35B-A3B",
     }
@@ -218,6 +219,7 @@ SERVING_MODEL_REPOS: dict[str, str] = {
     "Qwen/Qwen3.5-0.8B": "Qwen/Qwen3.5-0.8B",
     "Qwen/Qwen3.5-4B": "Qwen/Qwen3.5-4B",
     "Qwen/Qwen3.5-9B": "Freesolo-Co/Qwen3.5-9B-FP8",
+    "Qwen/Qwen3.5-9B-Base": "Qwen/Qwen3.5-9B-Base",
     "Qwen/Qwen3.8-27B": "Qwen/Qwen3.8-27B-FP8",
     "Qwen/Qwen3.6-35B-A3B": "Qwen/Qwen3.6-35B-A3B",
 }
@@ -532,6 +534,32 @@ MODELS: dict[str, ModelInfo] = {
 }
 
 
+# The pretrained checkpoint has the same architecture and native chat template as 9B,
+# but distinct weights, EOS metadata, and adapter identity. Never serve it via the
+# post-trained model's FP8 repository.
+MODELS["Qwen/Qwen3.5-9B-Base"] = replace(
+    MODELS["Qwen/Qwen3.5-9B"],
+    id="Qwen/Qwen3.5-9B-Base",
+    display_name="Qwen3.5 9B Base (pretrained)",
+    managed_revision="68c46c4b3498877f3ef123c856ecfde50c39f404",
+    serving=ServingCapacity(
+        gpu="H100",
+        serve_model_id="Qwen/Qwen3.5-9B-Base",
+        max_loras=16,
+        max_cpu_loras=16,
+        max_lora_rank=128,
+        max_model_len=262144,
+        max_num_seqs=8,
+        tensor_parallel_size=1,
+        gpu_memory_utilization=0.90,
+        image_limit=MAX_IMAGES_PER_CONVERSATION,
+    ),
+    notes="Pretrained-only Qwen3.5 9B; bf16 LoRA SFT/GRPO. Uses its own weights and "
+    "tokenizer, not the post-trained 9B. Native chat/thinking formatting is available for "
+    "fine-tuning; instruction following and reasoning are not post-trained. BF16 serving on H100.",
+)
+
+
 def list_models() -> list[ModelInfo]:
     return sorted(MODELS.values(), key=lambda m: (m.min_vram_gb, m.id))
 

{freesolo_flash_dev-1.4.6 → freesolo_flash_dev-1.4.8}/flash/engine/plan/vram.py

@@ -138,6 +138,7 @@ _SFT_CHUNKED_NLL_MODELS = frozenset(
         "Qwen/Qwen3.5-0.8B",
         "Qwen/Qwen3.5-4B",
         "Qwen/Qwen3.5-9B",
+        "Qwen/Qwen3.5-9B-Base",
         "Qwen/Qwen3.8-27B",
         "Qwen/Qwen3.6-35B-A3B",
     }

{freesolo_flash_dev-1.4.6 → freesolo_flash_dev-1.4.8}/flash/engine/profiling/sft_workload.py

@@ -12,6 +12,7 @@ from pathlib import Path
 from typing import Any, Protocol, TypedDict, cast
 
 from flash.content.multimodal import NormalizedImages
+from flash.content.processor import inherit_tokenizer_chat_template
 from flash.content.thinking import messages_for_chat_template
 from flash.engine.plan.recipe import RECIPE
 from flash.engine.plan.steps import resolve_update_horizon, sft_update_steps
@@ -190,11 +191,11 @@ def _default_processor_loader(model_id: str, revision: str):
 
     from flash.engine.support.huggingface import model_revision_kwargs
 
-    return AutoProcessor.from_pretrained(
-        model_id,
-        trust_remote_code=True,
-        **model_revision_kwargs(revision),
+    processor = AutoProcessor.from_pretrained(
+        model_id, trust_remote_code=True, **model_revision_kwargs(revision)
     )
+    inherit_tokenizer_chat_template(processor)
+    return processor
 
 
 def _packing_mode(

{freesolo_flash_dev-1.4.6 → freesolo_flash_dev-1.4.8}/flash/engine/worker/train/entry/backend_common.py

@@ -159,10 +159,7 @@ def _install_flash_attn(py: str) -> None:
             return
         except subprocess.CalledProcessError as e:
             if attempt == FLASH_ATTN_INSTALL_ATTEMPTS - 1:
-                # hand the arm back to the plane as infra-shaped: it retries as job_preempted on a
-                # fresh worker instead of failing the run. bounded by the plane's own retry budget
-                # (INFRA_RETRY_FLOOR), so a genuinely broken wheel spec still terminates rather than
-                # looping -- it just costs a few provisioning attempts to establish that.
+                # preserve the infrastructure failure in the terminal record after local retries.
                 raise RetriableInfraError(
                     f"prebuilt flash-attn wheel install failed {FLASH_ATTN_INSTALL_ATTEMPTS}x "
                     f"(exit {e.returncode}): {FLASH_ATTN_SPEC}"

{freesolo_flash_dev-1.4.6 → freesolo_flash_dev-1.4.8}/flash/engine/worker/train/rl/launch/inputs.py

@@ -22,6 +22,8 @@ import flash.engine.worker.model.decoding as _worker_decoding
 import flash.engine.worker.perf as _worker_perf
 import flash.engine.worker.train.rl.launch.config as _worker_config
 from flash.adapters.targets import LoraTargeting, resolve_lora_targeting
+from flash.content.processor import inherit_tokenizer_chat_template
+from flash.content.stop_tokens import chat_stop_token_ids
 from flash.content.structured_outputs import (
     describe_structured_outputs,
     parse_structured_outputs,
@@ -420,10 +422,11 @@ def _assemble_grpo_inputs(
         "max_turns": int(getattr(env, "max_turns", 0) or 0) if multi_turn else 0,
         # the child decides whether an assistant turn ended naturally or was cut off, and it has no
         # access to the model config -- so the full halting set is resolved here and handed over.
-        # the union of the tokenizer's eos and the model's generation_config eos, because a model can
-        # stop on a secondary id its tokenizer never exposes.
+        # Keep every checkpoint EOS plus any chat-turn boundary the model needs. Base checkpoints
+        # can use document EOS while the environment still requires one assistant turn at a time.
         "eos_token_ids": (
             generation_eos_from_cached_config(model_id, model_revision, tok)
+            | frozenset(chat_stop_token_ids(model_id, tok, is_chat=True) or ())
             if multi_turn
             else frozenset()
         ),
@@ -532,6 +535,7 @@ def _resolve_grpo_inputs(*, context: WorkerContext):
         processor = AutoProcessor.from_pretrained(
             model_id, trust_remote_code=True, **_worker_hf.model_revision_kwargs(model_revision)
         )
+        inherit_tokenizer_chat_template(processor)
         tok = processor.tokenizer
         image_pad_token_id = resolve_image_pad_token_id(processor, tok)
     else:

{freesolo_flash_dev-1.4.6 → freesolo_flash_dev-1.4.8}/flash/providers/_lifecycle/bootstrapping/bootstrap.py

@@ -56,7 +56,7 @@ _MAX_ATTEMPT_ID = (1 << 63) - 1
 
 
 class RetriableBootstrapError(RuntimeError):
-    """Infra-shaped failure → marker carries retriable=True → poller retries (job_preempted) instead of job_failed."""
+    """Infrastructure failure recorded in the attempt's terminal marker."""
 
 
 class WorkerInterrupted(BaseException):

{freesolo_flash_dev-1.4.6 → freesolo_flash_dev-1.4.8}/flash/providers/modal/jobs.py

@@ -68,8 +68,8 @@ def poll(handle, spec, *, log=None, deadline_at=None):
 
     def process_failure():
         # the provider exit status survives an artifact-store outage. ordinary process errors
-        # must not become paid preemption retries merely because their failure upload hit 429.
-        # signals/unknown status remain host-loss candidates; explicit retriable markers still win.
+        # must not be mislabeled as host loss merely because their failure upload hit 429.
+        # signals/unknown status remain host-loss candidates; explicit worker markers still win.
         if type(returncode) is int and 0 < returncode < 128:
             return f"Modal worker stopped with exit code {returncode} without a terminal record"
         return None

{freesolo_flash_dev-1.4.6 → freesolo_flash_dev-1.4.8}/flash/runner/supervise/retry_decision.py

@@ -8,7 +8,7 @@ from dataclasses import dataclass, replace
 from flash.core.spec import JobSpec
 
 INFRA_RETRY_FLOOR = 5
-INFRA_RETRY_FAILURES = frozenset({"stalled", "no_capacity", "poll_error", "job_preempted"})
+INFRA_RETRY_FAILURES = frozenset({"stalled", "no_capacity", "poll_error"})
 CANDIDATE_RETRY_FAILURES = INFRA_RETRY_FAILURES | {"oom"}
 CACHE_FALLBACK_FAILURES = frozenset({"no_capacity", "poll_error"})
 _STATE_KEYS = frozenset(
@@ -185,7 +185,11 @@ def _restore_last_decision(raw: object, counters: dict) -> PersistedRetryDecisio
         or not failure
     ):
         raise ValueError("persisted retry state has an invalid last decision")
-    return PersistedRetryDecision(attempt, failure, _restore_plan(raw["plan"], counters))
+    plan = _restore_plan(raw["plan"], counters)
+    # an older saved decision cannot authorize a failure the current policy no longer retries.
+    if plan.retry and failure not in CANDIDATE_RETRY_FAILURES:
+        plan = RetryPlan(False, "not retrying")
+    return PersistedRetryDecision(attempt, failure, plan)
 
 
 def _decision_snapshot(decision: PersistedRetryDecision | None) -> dict | None:
@@ -325,20 +329,6 @@ def transition_failure(
             observation,
             attempt,
         )
-    if failure == "job_preempted":
-        # Preemption says nothing about memory demand. Advancing the OOM floor here
-        # made a healthy worker at the largest allowed shape impossible to resume.
-        if state.infra_used >= state.infra_retries:
-            plan = RetryPlan(False, "not retrying: infrastructure retry budget exhausted")
-        else:
-            ordinal = state.infra_used + 1
-            state = replace(state, infra_used=ordinal, cache_retry_shape=None)
-            plan = RetryPlan(
-                True,
-                "retrying after preemption (resume from last checkpoint)",
-                ordinal,
-            )
-        return _finish(state, plan, observation, attempt)
     floor = max(state.usable_vram_floor, _candidate_usable_vram_gb(chosen))
     state = replace(state, usable_vram_floor=floor, cache_retry_shape=None)
     if candidates is not None and not any(

{freesolo_flash_dev-1.4.6 → freesolo_flash_dev-1.4.8}/flash/serve/deployment/profiles.py

@@ -219,6 +219,34 @@ _PROFILES: dict[str, ServingProfile] = {
         modal_gpu_request="L40S",
         modal_live_qualified=True,
     ),
+    "Qwen/Qwen3.5-9B-Base": ServingProfile(
+        model_id="Qwen/Qwen3.5-9B-Base",
+        modality="multimodal",
+        served_model="Qwen/Qwen3.5-9B-Base",
+        served_model_revision="68c46c4b3498877f3ef123c856ecfde50c39f404",
+        tokenizer_model="Qwen/Qwen3.5-9B-Base",
+        dtype="bfloat16",
+        quantization=None,
+        kv_cache_dtype="fp8",
+        max_model_len=262144,
+        max_num_seqs=8,
+        max_num_batched_tokens=None,
+        max_loras=16,
+        max_cpu_loras=16,
+        max_lora_rank=128,
+        gpu_memory_utilization=0.90,
+        cpu_offload_gb=0.0,
+        image_limit=MAX_IMAGES_PER_CONVERSATION,
+        mm_processor_cache_gb=0.0,
+        enable_tower_connector_lora=True,
+        reasoning_parser="qwen3",
+        engine_args={"enforce_eager": False},
+        tokenizer_kwargs={},
+        processor_kwargs={},
+        modal_gpu="H100",
+        modal_gpu_request="H100!",
+        modal_live_qualified=True,
+    ),
     "Qwen/Qwen3.8-27B": ServingProfile(
         model_id="Qwen/Qwen3.8-27B",
         modality="multimodal",

freesolo_flash_dev-1.4.8/flash/serve/request/schema_types.py

@@ -0,0 +1,36 @@
+"""Exact JSON Schema type matching for tool declarations and arguments."""
+
+import math
+from decimal import Decimal
+from typing import Any
+
+
+def _matches_type(value: Any, schema_type: str | list[str]) -> bool:
+    if type(schema_type) is list:
+        return any(_matches_type(value, member) for member in schema_type)
+    if schema_type == "null":
+        return value is None
+    if schema_type == "boolean":
+        return type(value) is bool
+    if schema_type == "integer":
+        return (
+            type(value) is int
+            or (type(value) is Decimal and _decimal_is_integral(value))
+            or (type(value) is float and math.isfinite(value) and value.is_integer())
+        )
+    if schema_type == "number":
+        if type(value) is Decimal:
+            return value.is_finite()
+        return type(value) is int or (type(value) is float and math.isfinite(value))
+    if schema_type == "string":
+        return type(value) is str
+    if schema_type == "array":
+        return type(value) is list
+    return type(value) is dict
+
+
+def _decimal_is_integral(value: Decimal) -> bool:
+    if not value.is_finite():
+        return False
+    digits, exponent = value.as_tuple().digits, value.as_tuple().exponent
+    return exponent >= 0 or all(digit == 0 for digit in digits[exponent:])

{freesolo_flash_dev-1.4.6 → freesolo_flash_dev-1.4.8}/flash/serve/request/tool_calls.py

@@ -12,6 +12,7 @@ from typing import Any
 
 from flash.serve.contract.protocol import MAX_CHAT_REQUEST_BYTES, TEXT_TYPES
 from flash.serve.request import text_scan
+from flash.serve.request.schema_types import _decimal_is_integral, _matches_type
 from flash.serve.request.text_scan import TOOL_CALL_END, TOOL_CALL_START
 from flash.serve.request.text_scan import skip_whitespace as _skip_whitespace
 from flash.serve.request.tool_template import last_query_index, rendered_turn_prefix
@@ -37,6 +38,7 @@ _MAX_FIXED_DECIMAL_DIGITS = _MAX_NUMERIC_LITERAL_DIGITS = 1024
 _MAX_NUMERIC_LITERAL_EXPONENT = 1_000_000
 _MAX_ENUM_INTEGER_MAGNITUDE = 10**_MAX_NUMERIC_LITERAL_DIGITS
 _SCHEMA_TYPES = frozenset(["array", "boolean", "integer", "null", "number", "object", "string"])  # fmt: skip
+_SCALAR_SCHEMA_TYPES = _SCHEMA_TYPES - {"array", "object"}
 _SCHEMA_KEYS = frozenset(["additionalProperties", "description", "enum", "items", "properties", "required", "type"])  # fmt: skip
 
 
@@ -55,7 +57,8 @@ class FunctionTool:
 
 
 def qualified_tool_parser(base_model: str) -> str | None:
-    return TOOL_PARSER_QWEN3_CODER if base_model == "Qwen/Qwen3.5-9B" else None
+    supported = {"Qwen/Qwen3.5-9B", "Qwen/Qwen3.5-9B-Base"}
+    return TOOL_PARSER_QWEN3_CODER if base_model in supported else None
 
 
 def normalize_tools(
@@ -137,8 +140,6 @@ def validate_tool_request_contract(
 
     if not tools_active(tools, tool_choice):
         return
-    if thinking:
-        raise error_type("tools are not supported for thinking-enabled generation")
     if tool_parser != TOOL_PARSER_QWEN3_CODER:
         raise error_type("this serving engine is not qualified for tool calling")
 
@@ -253,7 +254,11 @@ def validate_tool_history_replay(
         # would accept a turn the parser rejects as ambiguous.
         try:
             _validate_template_roundtrip(
-                probe, rendered_turn_prefix(message, message_index > last_query)
+                probe,
+                rendered_turn_prefix(message, message_index > last_query),
+                answer_prefix=rendered_turn_prefix(
+                    message, message_index > last_query, answer_only=True
+                ),
             )
         except ValueError as exc:
             raise error_type(f"message {message_index} {exc}") from exc
@@ -317,7 +322,22 @@ def _normalize_schema(
     if unknown:
         raise error_type(f"{path} uses unsupported schema keyword(s): {', '.join(sorted(unknown))}")
     schema_type = raw.get("type")
-    if type(schema_type) is not str or schema_type not in _SCHEMA_TYPES:
+    if type(schema_type) is list:
+        if (
+            not 1 <= len(schema_type) <= len(_SCALAR_SCHEMA_TYPES)
+            or any(
+                type(member) is not str or member not in _SCALAR_SCHEMA_TYPES
+                for member in schema_type
+            )
+            or len(set(schema_type)) != len(schema_type)
+        ):
+            raise error_type(
+                f"{path}.type must be a nonempty unique list of supported scalar types"
+            )
+        if root or direct:
+            raise error_type(f"{path}.type unions are supported only inside JSON arrays or objects")
+        schema_type = list(schema_type)
+    elif type(schema_type) is not str or schema_type not in _SCHEMA_TYPES:
         raise error_type(f"{path}.type must be one supported JSON Schema type")
     if root and schema_type != "object":
         raise error_type(f"{path} must be a root object schema")
@@ -498,7 +518,8 @@ def _validate_tool_result(
 
 def _canonicalize_integer_values(value: Any, schema: Mapping[str, Any]) -> Any:
     schema_type = schema["type"]
-    if schema_type == "integer" and type(value) is Decimal:
+    types = schema_type if type(schema_type) is list else [schema_type]
+    if "integer" in types and "number" not in types and type(value) is Decimal:
         return value.to_integral_value()
     if schema_type == "object":
         properties = schema["properties"]
@@ -511,35 +532,6 @@ def _canonicalize_integer_values(value: Any, schema: Mapping[str, Any]) -> Any:
     return value
 
 
-def _matches_type(value: Any, schema_type: str) -> bool:
-    if schema_type == "null":
-        return value is None
-    if schema_type == "boolean":
-        return type(value) is bool
-    if schema_type == "integer":
-        return (
-            type(value) is int
-            or (type(value) is Decimal and _decimal_is_integral(value))
-            or (type(value) is float and math.isfinite(value) and value.is_integer())
-        )
-    if schema_type == "number":
-        if type(value) is Decimal:
-            return value.is_finite()
-        return type(value) is int or (type(value) is float and math.isfinite(value))
-    if schema_type == "string":
-        return type(value) is str
-    if schema_type == "array":
-        return type(value) is list
-    return type(value) is dict
-
-
-def _decimal_is_integral(value: Decimal) -> bool:
-    if not value.is_finite():
-        return False
-    digits, exponent = value.as_tuple().digits, value.as_tuple().exponent
-    return exponent >= 0 or all(digit == 0 for digit in digits[exponent:])
-
-
 def _load_exact_json(value: str) -> Any:
     try:
         decoded = json.loads(
@@ -603,6 +595,8 @@ def _historical_replay_type(value: Any) -> str:
 def _validate_template_roundtrip(
     probe: Sequence[tuple[FunctionTool, dict[str, Any], dict[str, Any]]],
     prefix: str = "",
+    *,
+    answer_prefix: str | None = None,
 ) -> None:
     from flash.serve.runtime.tool_calls import parse_qwen3_coder_output
 
@@ -630,6 +624,8 @@ def _validate_template_roundtrip(
         size += len(blocks[-1])
         if size > _MAX_REPLAY_TEMPLATE_CHARS:
             raise ValueError(failure)
+    if prefix and answer_prefix is not None:
+        blocks[0] = answer_prefix
     text = "".join(blocks)
     replay_tools = _merged_replay_tools(probe)
     # replay must grant exactly what a generation parse of this same text would grant. restating

{freesolo_flash_dev-1.4.6 → freesolo_flash_dev-1.4.8}/flash/serve/request/tool_template.py

@@ -1,8 +1,7 @@
 """the text the qwen tool template renders around an assistant turn's call blocks.
 
-replay validation has to see the same prefix the model does. the parser selects the first complete
-`<tool_call>` marker in the turn, so a marker anywhere ahead of the call blocks steals the parse,
-and a marker the template discards must not be validated as though it survived.
+Replay validates the rendered answer prefix. Reasoning is counted toward the full
+rendered size, but only text after its first close can contain executable tools.
 """
 
 from __future__ import annotations
@@ -55,7 +54,9 @@ def last_query_index(messages: Sequence[Mapping[str, Any]]) -> int:
     return len(messages) - 1
 
 
-def rendered_turn_prefix(message: Mapping[str, Any], with_reasoning: bool) -> str:
+def rendered_turn_prefix(
+    message: Mapping[str, Any], with_reasoning: bool, *, answer_only: bool = False
+) -> str:
     """the text the template renders before this turn's call blocks."""
     # deriving the prefix from the same normalization the prompt path applies is what keeps this
     # exact. validating the raw request fields instead would reject a turn whose markers the
@@ -84,6 +85,8 @@ def rendered_turn_prefix(message: Mapping[str, Any], with_reasoning: bool) -> st
     # earlier turn's reasoning is dropped, so including it would reject a replayable turn.
     if with_reasoning and reasoning:
         prefix += f"{THINK_START}\n{reasoning}\n{THINK_END}\n\n"
+        if answer_only:
+            prefix = prefix.partition(THINK_END)[2]
     if content:
         prefix += f"{content}\n\n"
     return prefix