lobes-cli 0.89.1__tar.gz → 0.89.2__tar.gz

lobes_cli-0.89.2/.agex/data/pr/323/await.json

@@ -0,0 +1,13 @@
+{
+  "schema": 1,
+  "state": "done",
+  "pr": 323,
+  "exit_code": 0,
+  "outcome": "clean",
+  "started_at": "2026-10-18T11:10:48.671094+00:00",
+  "finished_at": "2026-10-18T11:11:56.545796+00:00",
+  "briefing": "# `agex pr read` \u2014 PR #323\n\n- State: **OPEN** (fix: qwen3_coder_thinking passes reasoning=False on vLLM >= 0.30 (strict+thinking repeat) \u2014 #310 d5)\n- Branch: `fix/plugin-reasoning-gate` \u2192 `main`\n- URL: https://github.com/agentculture/lobes-cli/pull/323\n\n## CI checks\n\n| Check | Status | Conclusion |\n|---|---|---|\n| test | in_progress | \u2014 |\n| test | in_progress | \u2014 |\n| lint | completed | success |\n| secrets-scan | completed | success |\n| site-build | completed | success |\n| version-check | completed | success |\n| GitGuardian Security Checks | completed | success |\n\n\n## SonarCloud\n\n_Project not on SonarCloud (skipped)._\n\n## Comments\n\n- **[top-level]** `OriNachum`: /agentic_review\n- **[top-level]** `qodo-code-review[bot]`: <!-- qodo:billing-blocked -->\n\n**\u24d8 Qodo reviews are paused because the subscription is no longer active.** Ask your workspace admin to reactivate the subscription to resume reviews. [Manage...\n- **[top-level]** `qodo-code-review[bot]`: <!-- qodo:billing-blocked -->\n\n**\u24d8 Qodo reviews are paused because the subscription is no longer active.** Ask your workspace admin to reactivate the subscription to resume reviews. [Manage...\n\n\n## Qodo review\n\n_No Qodo review found._\n\n## Readiness\n\nAll required reviewers have posted feedback.\n\n---\n**Next step:** PR #323 is ready \u2014 wait for human merge.\n",
+  "gate_status": null,
+  "threads_unresolved": 0,
+  "ci_state": "ok"
+}

{lobes_cli-0.89.1 → lobes_cli-0.89.2}/.agex/data/pr/events.jsonl

@@ -239,3 +239,9 @@
 {"ts":"2026-10-07T00:01:53.296199+00:00","type":"pr_webhook_posted","pr":293,"event":"pr_opened"}
 {"ts":"2026-10-07T00:02:56.775080+00:00","type":"readiness_arrived","pr":293,"waited_secs":60}
 {"ts":"2026-10-07T00:03:01.419898+00:00","type":"pr_read","pr":293,"comment_count":3,"threads_unresolved":0,"ci_state":"ok"}
+{"ts":"2026-10-18T11:10:46.372078+00:00","type":"pr_opened","pr":323,"title":"fix: qwen3_coder_thinking passes reasoning=False on vLLM >= 0.30 (strict+thinking repeat) \u2014 #310 d5"}
+{"ts":"2026-10-18T11:10:47.900887+00:00","type":"pr_review_triggered","pr":323,"command":"/agentic_review"}
+{"ts":"2026-10-18T11:10:48.656513+00:00","type":"pr_webhook_posted","pr":323,"event":"pr_opened"}
+{"ts":"2026-10-18T11:10:48.671713+00:00","type":"pr_await_detach_spawned","pr":323,"max_wait":1800}
+{"ts":"2026-10-18T11:11:52.039761+00:00","type":"readiness_arrived","pr":323,"waited_secs":60}
+{"ts":"2026-10-18T11:11:56.546218+00:00","type":"pr_await_detach_done","pr":323,"outcome":"clean","exit_code":0}

{lobes_cli-0.89.1 → lobes_cli-0.89.2}/CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to this project are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
 adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.89.2] - 2026-10-18
+
+### Fixed
+
+- `qwen3_coder_thinking` plugin: on vLLM >= 0.30.0, which starts the structured-output grammar only after reasoning ends, the plugin now passes vLLM's own `reasoning` flag through (`False` on every engine measured) instead of deriving it per request, and logs which mode it chose at import. The thinking-prefixed grammar it built before masked EOS there, so a strict tool call with thinking repeated until `max_tokens` (measured on 0.30.0, 0.31.0 and 0.32.0rc1). Older engines keep the per-request derivation; an unreadable `vllm.__version__` refuses to boot (#310 deviation d5).
+- `lobes assess --strict-tools`: a strict leg that hits `max_tokens` (`finish_reason=length`) is no longer counted as a clean call, so the matrix now catches the repeat-until-`max_tokens` failure.
+
 ## [0.89.1] - 2026-10-17
 
 ### Added

{lobes_cli-0.89.1 → lobes_cli-0.89.2}/CLAUDE.md

@@ -145,7 +145,13 @@ tool-parser plugin (`lobes/vllm_plugins/`, loaded via vLLM's own
 `--tool-parser-plugin` file-path surface, cortex/main lane only — mirrors
 the `preserve_thinking` #93 scoping) — it derives the grammar's `reasoning`
 flag from the request's own `enable_thinking` instead of the hardcoded
-`False`. A separate, default-off gateway knob (`GATEWAY_FORCE_STRICT_TOOLS`)
+`False`. **That derivation is engine-dependent (#310 deviation d5,
+2026-10-18):** vLLM 0.30.0 and later start the grammar only after reasoning
+ends, so a thinking-prefixed grammar masks EOS and a strict call repeats until
+`max_tokens`; on those engines the plugin passes vLLM's own `reasoning` flag
+through (`False` on every engine measured) (measured on 0.30.0, 0.31.0 and 0.32.0rc1;
+`docs/evidence/2026-10-18-accept-vllm-031-spark-cortex.txt`). The boundary is
+the measured one, chosen by the plugin from `vllm.__version__`. A separate, default-off gateway knob (`GATEWAY_FORCE_STRICT_TOOLS`)
 opts existing callers into strict schemas without a client-side change, with
 a retry-without-strict fallback on a grammar-compile failure. See
 `docs/qwen3.6-27b-text-nvfp4-mtp.md`, `docs/openai-api.md`, and

{lobes_cli-0.89.1 → lobes_cli-0.89.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lobes-cli
-Version: 0.89.1
+Version: 0.89.2
 Summary: lobes — run, assess, and switch the local vLLM model.
 Project-URL: Homepage, https://github.com/agentculture/lobes-cli
 Project-URL: Issues, https://github.com/agentculture/lobes-cli/issues

lobes_cli-0.89.2/docs/evidence/2026-10-18-accept-vllm-031-spark-cortex.txt

@@ -0,0 +1,71 @@
+ACCEPTANCE — DGX Spark cortex on vLLM 0.31.0 (v0.31.0-ubuntu2404), with the d5 plugin fix
+Issue #310 · plan vllm-0-31-0-fleet task t12 · 2026-10-18 · operator: lobes (Claude)
+Continues docs/evidence/2026-10-17-accept-vllm-031-spark-cortex.txt (partial), whose three findings are closed:
+  (1) governor GPU loss -> explicit GPU devices (d2), governor re-attached and verified below;
+  (2) strict+thinking regression -> ROOT CAUSE is the lobes plugin, not the engine (d5), fixed and verified below;
+  (3) hot acpitz zones -> thermal shed raised to 98/94 C (c55), active on the re-imaged 0.89.1 gateway below.
+Status: ACCEPTED on the official pin. Deviations d3 (split pin) and d4 (eugr exception) are withdrawn (d6).
+
+STRICT + THINKING — ROOT CAUSE (d5)
+  Request: tools=[finish(summary: string), strict: true], tool_choice auto, temperature 0, max_tokens 2048,
+  thinking on (template default). Reproduced on three engines, 3/3 runs each, through cortex-spark:
+    v0.30.0-ubuntu2404 and v0.31.0-ubuntu2404 (2026-10-17/18, partial transcript): ~78 calls, finish=length.
+    eugr GB10 nightly (vLLM 0.32.0rc1.dev301, ghcr.io/spark-arena/dgx-vllm-eugr-nightly@sha256:cc47adc1...):
+      run 1: calls=78 finish=length completion_tokens=2048 first_args={"summary": "hello"}
+      run 2: calls=78 finish=length completion_tokens=2048
+      run 3: calls=77 finish=length completion_tokens=2048
+    Same image, DSpark speculative config removed (isolation): 78 / 78 / 78 calls, finish=length.
+      -> DSpark ruled out.
+  Offline (CPU, xgrammar matcher, Qwen3.8 tokenizer), the plugin's thinking-prefixed grammar
+  (tag "" ... "</think>", then "\n\n", then triggered_tags <tool_call>):
+    fed the full text (thinking + </think> + one call): EOS allowed after the call.
+    fed only the text AFTER </think> (one call):         EOS NOT allowed; another <tool_call> allowed.
+    Same on all four combinations of {nightly grammar, new grammar} x {nightly xgrammar, eugr xgrammar}.
+  Reading: vLLM >= 0.30 starts the structured-output grammar only after reasoning ends, so the matcher sits
+  inside the plugin's thinking tag, accepts each tool call as thinking text, and masks EOS until max_tokens.
+  (The 2026-10-18 handoff's "grammar identical across engines" was wrong: the new engines add
+  excludes [<think>, </think>] to the thinking block's any_text. It does not change the result; lapse l11.)
+  Live test of the fix: the deployed plugin copy hand-patched to pass reasoning=False (backup
+  qwen3_thinking_tool_parser.py.bak-*-reasonfalse), eugr image:
+    DSpark off: 1 / 1 / 1 calls, finish=tool_calls, 45 tokens each; reasoning kept (72 chars)
+    DSpark on:  1 / 1 / 1 calls, finish=tool_calls, 65 tokens each
+    enforcement control, summary maxLength=3, prompt demands a 43-char string:
+      strict=True  -> {"summary": "the"}                                          (grammar enforced)
+      strict=False -> {"summary": "the quick brown fox jumps over the lazy dog"}  (unconstrained)
+    (an enum control did not discriminate: the model obeyed the enum with and without strict)
+
+ENGINE COMPARISON (cortex, DSpark n=7, 262144 window, util 0.58; lobes benchmark 1000 in / 1000 out)
+  eugr 0.32.0rc1.dev301:  decode 17.2 / 17.2 tok/s, prefill 887 tok in 1.12 s   (1 run;  hottest zone 87.1 C)
+  official 0.31.0:        decode 15.9 / 15.9 tok/s, prefill 887 tok in 0.83 s   (2 runs, identical; 85.2 C)
+  spark2 nightly baseline (t11): 17.0 / 16.9 tok/s.
+  0.31.0 = ~92% of eugr, ~94% of the nightly baseline. The 2026-10-17 0.31.0 run measured 14.0 / 14.4; that does
+  not reproduce today and the difference is not isolated (that run's zones idled near 88 C; today's peaked 85 C).
+  Operator decision (d6): official 0.31.0 on the Sparks too; eugr stays a measured, unadopted candidate.
+
+ACCEPTANCE ON 0.31.0 (VLLM_NIGHTLY_IMAGE=vllm/vllm-openai@sha256:3fb023cc..., plugin patched per d5)
+  boot: `lobes up cortex --apply` 04:2xZ, healthy 04:25:32Z, engine (v0.31.0), KV cache 754,621 tokens.
+  strict+thinking replay: 1 / 1 / 1 calls, finish=tool_calls, 65 tokens each.
+  strict, thinking off: 1 call, 26 tokens.  non-strict + thinking: 1 call, reasoning 204 chars.
+  maxLength=3 control: strict -> "the"; non-strict -> the full 43-char string.
+  lobes assess --tools: 17*23=391 PASS, train 145 min PASS, reasoning field present, tool_choice:auto PASS.
+  lobes assess --strict-tools: strict_thinking PASS, strict_nothink PASS, matrix PASS.
+  lobes assess --preserve-thinking: +47 prompt tokens -> preserve_thinking LIVE.
+  vision colour controls (solid PNGs, 64 and 224 px, red/blue/green), gateway cortex-spark and lane direct: 12/12.
+
+GOVERNOR (d2)
+  vllm-primary devices: /dev/nvidia0 /dev/nvidiactl /dev/nvidia-modeset /dev/nvidia-uvm /dev/nvidia-uvm-tools.
+  `lobes governor run --container model-gear-vllm-primary --apply --bands "92:12,95:8,98:4" --pause-c 101
+   --resume-c 95` (lobes 0.89.1): first tick 04:53:48Z cpus=16 tz=62.4C; container NanoCpus=16000000000 after the
+  docker update; a fresh `nvidia-smi` exec inside the lane still reports NVIDIA GB10; /health 200.
+  It runs as a session background process, not a durable unit (follow-up).
+
+GATEWAY
+  `lobes doctor --repin-version --apply`: MODEL_GEAR_VERSION 0.86.0.dev642 -> 0.89.1.
+  `lobes up gateway --build --apply`: chain kept docker-compose.audio.yml; healthy; lobes-cli 0.89.1 in-container;
+  LOBES_THERMAL_SHED_C=98, LOBES_THERMAL_RESUME_C=94; AUDIO_URL set; /capabilities cortex ready=true.
+  First mesh reannounce reported "Connection reset by peer"; afterwards cortex-spark, cortex-spark2 and plain
+  cortex all answered 200 through this gateway.
+
+END STATE (04:5xZ): Spark cortex on official v0.31.0-ubuntu2404 with DSpark, explicit GPU devices, governor
+  attached, hand-patched plugin (reasoning=False; the packaged engine-aware fix lands in R2, t14), gateway 0.89.1
+  with the 98/94 C shed. innereye down by design. spark2 untouched (nightly) until t13.

{lobes_cli-0.89.1 → lobes_cli-0.89.2}/docs/qwen3.6-27b-text-nvfp4-mtp.md

@@ -237,7 +237,24 @@ heavier co-resident agents need the headroom.
    rebuild (the pin is unchanged) and no served-model change — this
    constrains *around* the template drift, it does not fix the drift itself
    (out of scope here; filing the `reasoning=False` hardcode upstream is a
-   tracked follow-up). A companion, independent gateway knob
+   tracked follow-up).
+
+   **The derivation is engine-dependent (#310 deviation d5, 2026-10-18).**
+   It is right only on an engine that applies the grammar from the first
+   generated token, which the nightlies did. vLLM 0.30.0 and later start the
+   grammar only **after** reasoning ends. A thinking-prefixed grammar then
+   sits inside its thinking tag: every tool call is accepted as thinking
+   text, EOS stays masked, and a strict request repeats the call until
+   `max_tokens` (about 78 calls in 2048 tokens, on 0.30.0, 0.31.0 and
+   0.32.0rc1, with and without DSpark). On those engines the plugin passes
+   vLLM's own `reasoning` flag through (`False` on every engine measured),
+   chosen from `vllm.__version__` at import and logged; an unreadable version
+   refuses to boot. A `0.29.x` dev build is classified as pre-0.30. Measured on the DGX Spark:
+   one call with reasoning kept, and a `maxLength=3` control still enforced
+   under strict (`docs/evidence/2026-10-18-accept-vllm-031-spark-cortex.txt`).
+   The 0.30.0 boundary is the measured one, not a proven upstream change
+   point: 0.27-0.29 are unmeasured and keep the derivation, and the vLLM
+   change behind it is not isolated. A companion, independent gateway knob
    (`GATEWAY_FORCE_STRICT_TOOLS`) that injects `strict: true` for existing
    callers who don't set it themselves is documented in
    [`docs/openai-api.md`](openai-api.md) and

{lobes_cli-0.89.1 → lobes_cli-0.89.2}/lobes/assess.py

@@ -433,7 +433,9 @@ def _strict_matrix_leg(url: str, model: str, *, strict: bool, enable_thinking: b
 
     A CLEAN call means: at least one ``tool_calls`` entry, every name one of
     the offered tools (a parser-salvage mangle shows up as e.g.
-    ``'finish"'``), and every ``arguments`` string parsing as a JSON object.
+    ``'finish"'``), every ``arguments`` string parsing as a JSON object, and a
+    ``finish_reason`` other than ``length`` (a call repeated until
+    ``max_tokens`` is well-formed call by call, #310 d5).
     The baseline (non-strict) leg only requires an answer — unconstrained
     decoding is allowed to drift; that is exactly why the strict legs exist.
     """
@@ -449,14 +451,23 @@ def _strict_matrix_leg(url: str, model: str, *, strict: bool, enable_thinking: b
         choice = (d.get("choices") or [{}])[0]
         msg = choice.get("message") or {}
         names, args_ok = _parse_leg_tool_calls(msg)
-        clean = bool(names) and args_ok and all(n in offered for n in names)
+        finish = choice.get("finish_reason")
+        # A strict leg that ran out of tokens is not clean even when every call
+        # is well-formed: that is the #310 d5 repeat-until-max_tokens failure.
+        ran_out = finish == "length"
+        clean = bool(names) and args_ok and all(n in offered for n in names) and not ran_out
         answered = bool(names) or bool(msg.get("content"))
+        error = (
+            f"hit max_tokens with {len(names)} tool call(s) (finish_reason=length)"
+            if strict and ran_out
+            else None
+        )
         return {
             "ok": clean if strict else answered,
             "clean": clean,
             "tool_calls": names,
-            "finish": choice.get("finish_reason"),
-            "error": None,
+            "finish": finish,
+            "error": error,
         }
     except (KeyError, IndexError, TypeError, AttributeError) as exc:
         return _leg_error(f"unexpected response shape ({exc.__class__.__name__}: {exc})")

{lobes_cli-0.89.1 → lobes_cli-0.89.2}/lobes/templates/fleet/docker-compose.yml

@@ -189,6 +189,8 @@ services:
     #     registers this name from the mounted file. Falls back to plain
     #     upstream qwen3_coder if an operator overrides PRIMARY_TOOL_CALL_PARSER
     #     in .env (e.g. to run a non-thinking primary here).
+    #     On vLLM >= 0.30.0 the grammar starts only after reasoning ends, so the
+    #     plugin passes vLLM's own reasoning flag through instead (#310 d5).
     #
     #   --enable-prefix-caching  Mamba prefix caching is experimental for this
     #     hybrid 27B; functional, watch for drift.

{lobes_cli-0.89.1 → lobes_cli-0.89.2}/lobes/vllm_plugins/__init__.py

@@ -25,9 +25,11 @@ Public modules:
 
 - :mod:`lobes.vllm_plugins.qwen3_thinking_tool_parser` — registers the
   ``qwen3_coder_thinking`` tool-call parser (a reasoning-aware variant of the
-  upstream ``qwen3_coder`` parser) for the cortex/main generate lane, deriving
-  the structural-tag grammar's ``reasoning`` flag from the request's own
-  effective ``enable_thinking`` state.
+  upstream ``qwen3_coder`` parser) for the cortex/main generate lane. On an
+  engine that applies the grammar from the first token it derives the
+  structural-tag grammar's ``reasoning`` flag from the request's own effective
+  ``enable_thinking`` state; on vLLM >= 0.30.0, which starts the grammar only
+  after reasoning ends, it passes vLLM's own flag through (#310 d5).
 
 See ``docs/`` for the full story on why the served vLLM build's hardcoded
 ``reasoning=False`` breaks strict tool calling for a thinking model.

{lobes_cli-0.89.1 → lobes_cli-0.89.2}/lobes/vllm_plugins/qwen3_thinking_tool_parser.py

@@ -21,13 +21,26 @@ Qwen3.6 thinking model that produces a grammar that cannot accept the
 ``reasoning=True`` fixes the grammar, but then REQUIRES a closing
 ``</think>`` in the output — so ``reasoning`` must track whether the request
 actually has thinking enabled, not just be flipped on unconditionally.
+
+That per-request derivation is right only on an engine that applies the
+grammar from the first generated token. vLLM 0.30.0 and later (measured on
+0.30.0, 0.31.0 and 0.32.0rc1, #310 deviation d5) start it only AFTER reasoning
+ends, so a thinking-prefixed grammar sits inside its thinking tag forever:
+every tool call is accepted as thinking text, EOS stays masked, and a strict
+request repeats the call until ``max_tokens``. There the plugin passes
+``reasoning=False`` for every request. The boundary is the measured one, not a
+proven upstream change point: 0.27-0.29 are unmeasured and keep the
+derivation, and the vLLM change behind it is not isolated.
 """
 
 from __future__ import annotations
 
 import inspect
+import logging
+import re
 from typing import Any
 
+import vllm
 from vllm.tool_parsers import ToolParserManager
 from vllm.tool_parsers import qwen3_engine_tool_parser as _qwen3_engine_tool_parser_module
 
@@ -63,6 +76,45 @@ def effective_reasoning(request: Any) -> bool:
     return bool(chat_template_kwargs["enable_thinking"])
 
 
+#: First engine measured to start the structured-output grammar after reasoning.
+_POST_REASONING_GRAMMAR_FROM = (0, 30)
+
+
+def grammar_starts_after_reasoning(version: str) -> bool:
+    """Return whether vLLM ``version`` applies the grammar only after reasoning.
+
+    Parses the leading ``major.minor`` (``"0.31.0+cu130"``, ``"0.31+cu130"``,
+    ``"0.30rc1"``, ``"0.32.0rc1.dev301+g..."`` and ``"0.26.1rc1.dev942+g..."``
+    all parse) and raises ``RuntimeError`` on anything else, so an engine whose
+    version cannot be read fails at boot instead of silently getting the wrong
+    grammar. A dev build is classified by its base release: a ``0.29.x`` nightly
+    keeps the per-request derivation even if it already carries the (not
+    isolated) upstream change, which is why the chosen mode is logged at import.
+    """
+    match = re.match(r"(\d+)\.(\d+)(?!\d)", version or "")
+    if match is None:
+        raise RuntimeError(
+            "qwen3_thinking_tool_parser: cannot read the vLLM version "
+            f"({version!r}), so it cannot tell whether the engine applies the "
+            "strict-tool grammar before or after reasoning; refusing to load."
+        )
+    return (int(match.group(1)), int(match.group(2))) >= _POST_REASONING_GRAMMAR_FROM
+
+
+_VLLM_VERSION = getattr(vllm, "__version__", "")
+_GRAMMAR_AFTER_REASONING = grammar_starts_after_reasoning(_VLLM_VERSION)
+
+logging.getLogger("vllm.lobes.qwen3_coder_thinking").info(
+    "qwen3_coder_thinking: vLLM %s -> structural-tag reasoning flag %s",
+    _VLLM_VERSION,
+    (
+        "passed through from vLLM (grammar starts after reasoning)"
+        if _GRAMMAR_AFTER_REASONING
+        else "derived per request from enable_thinking"
+    ),
+)
+
+
 # --- Loud import-surface assert --------------------------------------------
 # Pinned to the get_structural_tag surface of the nightly (0.26.1rc1:
 # `reasoning` only) and vLLM 0.31.0 (`reasoning` + `strict_level`), both in
@@ -128,16 +180,20 @@ _UNSET: Any = object()
 
 @ToolParserManager.register_module("qwen3_coder_thinking")
 class Qwen3ThinkingToolParser(Qwen3EngineToolParser):
-    """``Qwen3EngineToolParser`` with a request-aware ``reasoning`` flag.
+    """``Qwen3EngineToolParser`` with an engine- and request-aware ``reasoning`` flag.
 
     vLLM always calls ``get_structural_tag(request, reasoning=False)``
-    (abstract_parser._apply_structural_tag), which breaks strict tool calling
-    for a thinking model. Override so ``reasoning`` tracks the request's own
-    thinking state instead of the caller's hardcoded ``False``. 0.31.0 also
-    passes ``strict_level``; it is forwarded untouched when present and left
-    out when absent (nightly parent has no such parameter).
+    (abstract_parser._apply_structural_tag). On an engine that applies the
+    grammar from the first token that breaks strict tool calling for a
+    thinking model, so ``reasoning`` tracks the request's own thinking state.
+    On an engine that starts the grammar after reasoning (vLLM >= 0.30.0) the
+    grammar must not include the thinking block, so the caller's own
+    ``reasoning`` (``False`` from every engine measured) is passed through.
+    0.31.0 also passes ``strict_level``; it is forwarded untouched when present
+    and left out when absent (nightly parent has no such parameter).
     """
 
     def get_structural_tag(self, request, *, reasoning: bool = False, strict_level=_UNSET):
         extra = {} if strict_level is _UNSET else {"strict_level": strict_level}
-        return super().get_structural_tag(request, reasoning=effective_reasoning(request), **extra)
+        derived = reasoning if _GRAMMAR_AFTER_REASONING else effective_reasoning(request)
+        return super().get_structural_tag(request, reasoning=derived, **extra)

{lobes_cli-0.89.1 → lobes_cli-0.89.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lobes-cli"
-version = "0.89.1"
+version = "0.89.2"
 description = "lobes — run, assess, and switch the local vLLM model."
 readme = "README.md"
 license = "Apache-2.0"

{lobes_cli-0.89.1 → lobes_cli-0.89.2}/tests/test_assess.py

@@ -297,6 +297,36 @@ def test_strict_matrix_fails_on_mangled_strict_call(monkeypatch) -> None:
     assert r["legs"]["strict_thinking"]["clean"] is False
 
 
+def _repeated_calls_response(n: int = 78):
+    # The #310 d5 failure shape: a valid call repeated until max_tokens.
+    call = {"type": "function", "function": {"name": "finish", "arguments": '{"summary": "hello"}'}}
+    return {
+        "choices": [
+            {
+                "message": {"content": None, "tool_calls": [call] * n},
+                "finish_reason": "length",
+            }
+        ]
+    }
+
+
+def test_strict_matrix_fails_when_a_strict_leg_runs_to_max_tokens(monkeypatch) -> None:
+    # Every call is well-formed, so only finish_reason == "length" exposes it.
+    post, _ = _matrix_post(
+        {
+            (False, None): _clean_call_response(),
+            (True, None): _repeated_calls_response(),
+            (True, False): _clean_call_response(),
+        }
+    )
+    monkeypatch.setattr(A, "_post", post)
+    r = A.run_strict_tool_matrix("http://localhost:8001", "cortex")
+    assert r["passed"] is False
+    assert r["legs"]["strict_thinking"]["clean"] is False
+    assert r["legs"]["strict_thinking"]["finish"] == "length"
+    assert "max_tokens" in (r["legs"]["strict_thinking"]["error"] or "")
+
+
 def test_strict_matrix_cli_exit_codes(monkeypatch, capsys) -> None:
     post, _ = _matrix_post(
         {

{lobes_cli-0.89.1 → lobes_cli-0.89.2}/tests/test_vllm_plugin_thinking.py

@@ -162,12 +162,22 @@ class _FakeToolParserManager:
         return decorator
 
 
-def _install_stub_vllm(get_structural_tag, *, define_class: bool = True) -> _FakeToolParserManager:
+#: The served nightly's version string — an engine that applies the grammar from
+#: the first token, so the plugin must derive ``reasoning`` per request.
+NIGHTLY_VERSION = "0.26.1rc1.dev942+g4d2a1b0c3"
+
+
+def _install_stub_vllm(
+    get_structural_tag, *, define_class: bool = True, version: str | None = NIGHTLY_VERSION
+) -> _FakeToolParserManager:
     """Inject fake ``vllm``/``vllm.tool_parsers``/``...qwen3_engine_tool_parser``
     modules into ``sys.modules`` and return the fake ToolParserManager class
-    used, so callers can inspect ``.registered``.
+    used, so callers can inspect ``.registered``. ``version`` becomes
+    ``vllm.__version__`` (``None`` leaves it unset).
     """
     vllm_mod = types.ModuleType("vllm")
+    if version is not None:
+        vllm_mod.__version__ = version
     tool_parsers_mod = types.ModuleType("vllm.tool_parsers")
     qwen3_engine_mod = types.ModuleType("vllm.tool_parsers.qwen3_engine_tool_parser")
 
@@ -371,3 +381,108 @@ def test_import_surface_assert_raises_on_unknown_required_keyword(clean_vllm_stu
 
     with pytest.raises(RuntimeError, match="mode"):
         importlib.import_module(PLUGIN_MODULE_NAME)
+
+
+# ---------------------------------------------------------------------------
+# Engines that start the grammar only after reasoning ends (vLLM >= 0.30.0)
+# ---------------------------------------------------------------------------
+# Measured 2026-10-18 on the DGX Spark (#310 deviation d5,
+# docs/evidence/2026-10-18-accept-vllm-031-spark-cortex.txt): on 0.30.0, 0.31.0
+# and 0.32.0rc1 a thinking-prefixed grammar makes strict tool calls repeat until
+# max_tokens; reasoning=False gives one call with reasoning kept.
+
+
+@pytest.mark.parametrize(
+    "version",
+    [
+        "0.30.0",
+        "0.31.0",
+        "0.31.0+cu130",
+        "0.32.0rc1.dev301+g1ac942555.d20261016",
+        "1.0.0",
+        "0.30rc1",
+        "0.31+cu130",
+        "0.30.dev1",
+    ],
+)
+@pytest.mark.parametrize("thinking", [None, {"enable_thinking": True}, {"enable_thinking": False}])
+def test_post_reasoning_engine_always_gets_reasoning_false(
+    clean_vllm_stubs, version, thinking
+) -> None:
+    calls = []
+
+    def fake_get_structural_tag(self, request, *, reasoning: bool = False, strict_level="auto"):
+        calls.append(reasoning)
+
+    _install_stub_vllm(fake_get_structural_tag, version=version)
+    mod = importlib.import_module(PLUGIN_MODULE_NAME)
+
+    mod.Qwen3ThinkingToolParser().get_structural_tag(
+        _AttrRequest(chat_template_kwargs=thinking), reasoning=False
+    )
+
+    assert calls == [False]
+
+
+@pytest.mark.parametrize(
+    "version", [NIGHTLY_VERSION, "0.23.1rc1.dev672+g93d8f834d", "0.29.9", "0.29.1rc1.dev500+gabc"]
+)
+def test_pre_030_engine_keeps_per_request_derivation(clean_vllm_stubs, version) -> None:
+    calls = []
+
+    def fake_get_structural_tag(self, request, *, reasoning: bool = False):
+        calls.append(reasoning)
+
+    _install_stub_vllm(fake_get_structural_tag, version=version)
+    mod = importlib.import_module(PLUGIN_MODULE_NAME)
+    parser = mod.Qwen3ThinkingToolParser()
+
+    parser.get_structural_tag(_AttrRequest(chat_template_kwargs=None), reasoning=False)
+    parser.get_structural_tag(
+        _AttrRequest(chat_template_kwargs={"enable_thinking": False}), reasoning=False
+    )
+
+    assert calls == [True, False]
+
+
+@pytest.mark.parametrize("version", [None, "", "nightly", "v0.31.0"])
+def test_import_refuses_an_unreadable_engine_version(clean_vllm_stubs, version) -> None:
+    def fake_get_structural_tag(self, request, *, reasoning: bool = False):
+        return None
+
+    _install_stub_vllm(fake_get_structural_tag, version=version)
+
+    with pytest.raises(RuntimeError, match="version"):
+        importlib.import_module(PLUGIN_MODULE_NAME)
+
+
+def test_post_reasoning_engine_passes_the_callers_reasoning_through(clean_vllm_stubs) -> None:
+    # vLLM passes reasoning=False today; if a later engine passes True on
+    # purpose, the plugin must not hardcode it back to False.
+    calls = []
+
+    def fake_get_structural_tag(self, request, *, reasoning: bool = False, strict_level="auto"):
+        calls.append(reasoning)
+
+    _install_stub_vllm(fake_get_structural_tag, version="0.31.0")
+    mod = importlib.import_module(PLUGIN_MODULE_NAME)
+    parser = mod.Qwen3ThinkingToolParser()
+
+    parser.get_structural_tag(_AttrRequest(chat_template_kwargs=None), reasoning=True)
+    parser.get_structural_tag(_AttrRequest(chat_template_kwargs=None))
+
+    assert calls == [True, False]
+
+
+def test_plugin_logs_which_grammar_mode_it_chose(clean_vllm_stubs, caplog) -> None:
+    def fake_get_structural_tag(self, request, *, reasoning: bool = False):
+        return None
+
+    _install_stub_vllm(fake_get_structural_tag, version=NIGHTLY_VERSION)
+    with caplog.at_level("INFO"):
+        importlib.import_module(PLUGIN_MODULE_NAME)
+
+    assert any(
+        NIGHTLY_VERSION in r.getMessage() and "per request" in r.getMessage()
+        for r in caplog.records
+    )

{lobes_cli-0.89.1 → lobes_cli-0.89.2}/uv.lock

@@ -520,7 +520,7 @@ wheels = [
 
 [[package]]
 name = "lobes-cli"
-version = "0.89.1"
+version = "0.89.2"
 source = { editable = "." }
 
 [package.optional-dependencies]