coderouter-cli 1.8.1__tar.gz → 1.8.2__tar.gz

{coderouter_cli-1.8.1 → coderouter_cli-1.8.2}/CHANGELOG.md

@@ -6,6 +6,66 @@ versioning follows [SemVer](https://semver.org/).
 
 ---
 
+## [v1.8.2] — 2026-04-26 (doctor probe を thinking モデル対応に — Gemma 4 偽陽性の解消)
+
+**Theme: v1.8.1 リリース直後の深掘りで `doctor` の `num_ctx` / `streaming` probe が thinking モデルに対して偽陽性 NEEDS_TUNING を出していた事実を発見、probe の `max_tokens` バジェットを reasoning トークン消費分込みで設計し直した patch。**
+
+v1.8.1 で `coding` profile primary に置いた Gemma 4 26B の doctor 結果が `tool_calls [OK]` + `num_ctx [NEEDS TUNING]` + `streaming [NEEDS TUNING]` で「中途半端に動く」と判定されていたが、実機で curl 直叩きすると **Ollama OpenAI-compat 経由でも 5K トークンの canary echo-back に成功** することが判明。原因切り分けの結果、Gemma 4 が emit する非標準 `reasoning` フィールドが doctor probe の `max_tokens=32` (num_ctx) / `max_tokens=128` (streaming) を**思考トークンで食い切って `content=""` で `finish_reason='length'`** を返していた偽陽性と確定。実機検証 (M3 Max 64GB / Ollama 0.21.2) で Anthropic 互換 `/v1/messages` 経由 Gemma 4 26B が "Hello." を 2 秒で返すことも確認、**Gemma 4 26B は実用 OK** と最終判定。
+
+- Tests: 730 → **733** (+3: thinking provider declaration / registry-based / streaming の 3 件)
+- Runtime deps: 5 → 5 (20 sub-release 連続据え置き)
+- Backward compat: 完全互換、`providers.yaml` / `~/.coderouter/model-capabilities.yaml` 編集不要
+
+### Changes
+
+#### Doctor probe: thinking モデル対応バジェット選択
+
+- **`coderouter/doctor.py`**: `_probe_num_ctx` / `_probe_streaming` の `max_tokens` を thinking 検出付きの動的選択に変更。新 helper `_is_reasoning_model(provider, resolved)` が provider declaration / registry resolved の両方から `thinking` / `reasoning_passthrough` の真偽を見て、reasoning モデルのときだけ大きいバジェットを選ぶ。
+  - `_NUM_CTX_PROBE_MAX_TOKENS_DEFAULT = 256` (旧 32)、`_NUM_CTX_PROBE_MAX_TOKENS_THINKING = 1024`
+  - `_STREAMING_PROBE_MAX_TOKENS_DEFAULT = 512` (旧 128)、`_STREAMING_PROBE_MAX_TOKENS_THINKING = 1024`
+  - 非 thinking モデルは natural stop で早期終了するので無駄消費なし、thinking モデルは reasoning trace + 答えが収まる headroom
+
+#### Registry: 既知 thinking モデルに `thinking: true` 宣言
+
+- **`coderouter/data/model-capabilities.yaml`**: `gemma4:*` / `google/gemma-4*` / `qwen3.6:*` / `qwen/qwen3.6-*` に `thinking: true` を追加。これらは Ollama 経由で `reasoning` フィールドにかなりのトークンを吐く設計と確認済み。registry 経由で渡るので user は `providers.yaml` を触らなくても doctor の thinking バジェットが効く
+- **Qwen3.6 セクションのコメント更新**: v1.8.1 時点で「Ollama silent cap」と書いていた part を「**v1.8.2 で num_ctx / streaming は doctor 偽陽性と判明、tool_calls [NEEDS TUNING] が真の課題として残る**」に整理。`claude_code_suitability` 撤回判断は維持 (Qwen3.6 の tool_calls 不全は thinking 起因ではない別の真の課題)
+
+#### Tests
+
+- **`tests/test_doctor.py`**: 3 件追加
+  - `test_num_ctx_max_tokens_bumped_for_thinking_provider_declaration`: `provider.capabilities.thinking=True` → 1024
+  - `test_num_ctx_max_tokens_bumped_when_registry_says_thinking`: provider 宣言なし + registry 宣言あり → 1024
+  - `test_streaming_max_tokens_bumped_for_thinking_provider`: streaming probe も同経路で 1024 になる
+- 既存 `test_num_ctx_request_body_merges_extra_body_options` の `max_tokens == 32` assertion を `== 256` に更新 (新 baseline)
+- 既存 `test_streaming_request_body_carries_stream_true_and_merges_extra_body` に `max_tokens == 512` assertion を追加 (streaming baseline)
+
+### Why
+
+v1.8.1 article 執筆中に「note の流行モデル → ollama pull → 動かない」のうち Gemma 4 だけ `tool_calls [OK]` の **逆転勝利** だったはずが、`num_ctx [NEEDS TUNING]` も出ていて記事として煮え切らない状態だった。深掘りの結果、`/v1/chat/completions` 経由でも options は効く / `ollama ps` で context length 262144 が出る / **でも doctor は失敗** という矛盾を観測。`.choices[0].message.reasoning` フィールドに思考トークンが流れて `max_tokens=32` を消費していた事実を確認、**doctor 側の probe 設計が thinking モデル時代に追いついていない**ことが判明。
+
+これは「実機 evidence first」原則 (plan.md §5.4) の更に一段下のメタ教訓：**diagnostic ツール自身も diagnostic され続ける必要がある**。
+
+### Migration
+
+`pyproject.toml version 1.8.1 → 1.8.2`、`coderouter --version` は 1.8.2 を返す。**手元の `~/.coderouter/providers.yaml` は触らない限り完全に変化なし**。
+
+v1.8.1 で Gemma 4 26B を `claude_code_suitability` 抑え目に運用していたユーザーは v1.8.2 で doctor 再実行すると `num_ctx [OK]` + `streaming [OK]` まで通るはず。Qwen3.6 系の `tool_calls [NEEDS TUNING]` は本物 (thinking 起因ではない) なので引き続き coding chain primary には推奨しない。
+
+### Files touched
+
+```
+M  CHANGELOG.md
+M  coderouter/data/model-capabilities.yaml
+M  coderouter/doctor.py
+M  pyproject.toml
+M  plan.md
+M  docs/troubleshooting.md
+M  docs/articles/note-v1-8-1-reality-check.md   (or new file v1-8-2)
+M  tests/test_doctor.py
+```
+
+---
+
 ## [v1.8.1] — 2026-04-26 (実機検証反映 patch — mode_aliases 解決 + Gemma 4 第一候補化 + Ollama 既知問題ドキュメント化)
 
 **Theme: v1.8.0 出荷直後の実機検証 (M3 Max 32GB / Ollama 0.21.2) で踏んだ問題 3 件を patch で解消。**

{coderouter_cli-1.8.1 → coderouter_cli-1.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coderouter-cli
-Version: 1.8.1
+Version: 1.8.2
 Summary: Local-first, free-first, fallback-built-in LLM router. Claude Code / OpenAI compatible.
 Project-URL: Homepage, https://github.com/zephel01/CodeRouter
 Project-URL: Repository, https://github.com/zephel01/CodeRouter

{coderouter_cli-1.8.1 → coderouter_cli-1.8.2}/coderouter/data/model-capabilities.yaml

@@ -176,47 +176,59 @@ rules:
   # 「Claude Code 代替として最高」「local champ」と評価されている。
   #
   # ただし v1.8.0 までで `claude_code_suitability: ok` を declare していた
-  # のは note 記事の伝聞ベースの先回り宣言で、v1.8.1 (2026-04-26) の
-  # 実機検証 (M3 Max 32GB / Ollama 0.21.2) で次の課題が判明:
-  #   - num_ctx を declare 32768 しても Ollama 側で silent に縮められる
-  #     (canary echo-back probe 失敗)
+  # のは note 記事の伝聞ベースの先回り宣言で、v1.8.1 〜 v1.8.2
+  # (2026-04-26) の実機検証 (M3 Max 64GB / Ollama 0.21.2) で:
+  #   - num_ctx と streaming の NEEDS_TUNING は v1.8.2 で thinking モデル
+  #     用 probe バジェット拡大により偽陽性と判明 (doctor 側の課題)
   #   - tool_calls probe が native tool_calls / 修復可能 JSON のいずれも
-  #     返さず NEEDS_TUNING
-  #   - streaming probe が finish_reason='length' で 0 chars 打ち切り
-  # これらは Ollama 経由特有の問題で、HF / vLLM 直接ロードなら違う可能性。
-  # 確証ない以上、`claude_code_suitability` は撤回し `tools` 宣言だけ残す。
+  #     返さない真の課題が残る (Qwen3.6 系の Ollama 経由 tool 仕様未成熟)
+  # tool_calls 不全が解消されるまで `claude_code_suitability` は撤回。
   # 実機で動いたユーザーは `~/.coderouter/model-capabilities.yaml` で
   # `claude_code_suitability: ok` を上書きできる。
   # ------------------------------------------------------------------
 
+  # v1.8.2: thinking: true は doctor probe (num_ctx / streaming) が reasoning
+  # トークン消費分の max_tokens 余裕を確保するためのヒント。Qwen3 系は
+  # /think モードで thinking トークンを吐く設計なので true 宣言。
   - match: "qwen3.6:*"
     kind: openai_compat
     capabilities:
       tools: true
+      thinking: true
 
   - match: "qwen/qwen3.6-*"
     kind: openai_compat
     capabilities:
       tools: true
+      thinking: true
 
   # ------------------------------------------------------------------
-  # Gemma 4 family (v1.7-B 追加)
+  # Gemma 4 family (v1.7-B 追加、v1.8.2 で thinking: true 宣言)
   #
   # Google 公式 Gemma 4。Ollama 公式 tag は gemma4:e2b / e4b / 26b / 31b、
   # 全 variant が tools+vision+thinking 対応、E2B/E4B は audio もサポート。
   # MoE (26b は active 3.8B / total 25.2B)。note 記事で「日常・バランスの
   # 王者」と評価。Claude Haiku 互換性に近い簡潔な応答スタイル。
+  #
+  # v1.8.2 (2026-04-26): 実機検証 (M3 Max 64GB / Ollama 0.21.2 / gemma4:26b)
+  # で `reasoning` フィールドにかなりの量のトークンを吐く thinking モデル
+  # と確認。doctor probe の max_tokens=32 / 128 が thinking トークンに
+  # 食い切られて偽陽性 NEEDS_TUNING を出していた。registry で
+  # `thinking: true` を宣言すると doctor が probe バジェットを 1024 まで
+  # 引き上げて偽陽性を回避する。
   # ------------------------------------------------------------------
 
   - match: "gemma4:*"
     kind: openai_compat
     capabilities:
       tools: true
+      thinking: true
 
   - match: "google/gemma-4*"
     kind: openai_compat
     capabilities:
       tools: true
+      thinking: true
 
   # ------------------------------------------------------------------
   # GLM family (Z.AI / Zhipu AI、v1.7-B 追加)

{coderouter_cli-1.8.1 → coderouter_cli-1.8.2}/coderouter/doctor.py

@@ -433,6 +433,31 @@ _STREAMING_PROBE_USER_PROMPT = (
 # truncated". "1\n2\n...\n30" is ~80 chars; 40 chars covers the halfway
 # mark (1..20) which is already obviously-truncated territory.
 _STREAMING_PROBE_MIN_EXPECTED_CHARS = 40
+
+# v1.8.2: probe response budgets.
+#
+# Both num_ctx and streaming probes ask the model for a *short* answer
+# (the canary token / "1..30"). The original budgets (32 / 128 tokens)
+# assumed a non-thinking model that emits the answer immediately. On a
+# thinking model — Gemma 4 26B, Qwen3.6, gpt-oss, deepseek-r1 — the
+# upstream burns the entire budget on a hidden ``reasoning`` field
+# *before* emitting any visible ``content``, producing a false-positive
+# NEEDS_TUNING (canary missing / 0 chars streamed). Bumping the budget
+# is the cleanest fix: non-thinking models stop early at their natural
+# stop token (no waste), thinking models get headroom for the reasoning
+# trace plus the actual answer.
+#
+# Numbers picked from the v1.8.1 reality-check session
+# (docs/articles/note-v1-8-1-reality-check.md):
+#   * Gemma 4 26B reasoning prefix observed at ~150-300 tokens before
+#     content starts → 1024 covers reasoning + 30-line count comfortably.
+#   * Non-thinking baseline kept conservative-but-non-tight (256/512) to
+#     absorb stylistic preambles ("Sure, the answer is...") without
+#     burning extra cloud quota when the operator probes a paid endpoint.
+_NUM_CTX_PROBE_MAX_TOKENS_DEFAULT = 256
+_NUM_CTX_PROBE_MAX_TOKENS_THINKING = 1024
+_STREAMING_PROBE_MAX_TOKENS_DEFAULT = 512
+_STREAMING_PROBE_MAX_TOKENS_THINKING = 1024
 # Default ``num_predict`` suggested in the emitted patch. -1 would be
 # optimal (uncapped) but "4096" communicates intent more clearly to
 # operators unfamiliar with Ollama's sentinel value, and covers Claude
@@ -475,6 +500,42 @@ def _declared_num_ctx(provider: ProviderConfig) -> int | None:
     return val if isinstance(val, int) else None
 
 
+def _is_reasoning_model(
+    provider: ProviderConfig, resolved: ResolvedCapabilities
+) -> bool:
+    """v1.8.2: True iff the model is known to emit a hidden reasoning trace.
+
+    Thinking models (Gemma 4, Qwen3-with-/think, gpt-oss, deepseek-r1,
+    Claude Sonnet 4.5+ in extended-thinking mode) burn output tokens on a
+    ``reasoning`` field before any visible ``content`` is produced. The
+    num_ctx / streaming probes use small response budgets that get fully
+    consumed by the reasoning prefix, producing a false-positive
+    NEEDS_TUNING. Callers use this to choose a generous probe budget.
+
+    Three signals fire:
+      * provider declared ``capabilities.thinking: true`` in providers.yaml
+      * provider declared ``capabilities.reasoning_passthrough: true``
+        (the operator opted in to passing the raw reasoning to the client,
+        which is only meaningful for models that emit it)
+      * registry resolved ``thinking: true`` for this (kind, model) pair
+
+    Conservative bias — when both provider declaration and registry are
+    silent, treat as non-reasoning. The probe still completes for thinking
+    models in that case (they just hit ``finish_reason='length'`` like
+    they did pre-v1.8.2), but at least the new generous default budget
+    (256 / 512) gives more headroom than the old 32 / 128.
+    """
+    if provider.capabilities.thinking is True:
+        return True
+    if provider.capabilities.reasoning_passthrough is True:
+        return True
+    if resolved.thinking is True:
+        return True
+    if resolved.reasoning_passthrough is True:
+        return True
+    return False
+
+
 _PROBE_BASIC_USER_PROMPT = "Reply with exactly the single word: PONG"
 _PROBE_TOOLS_USER_PROMPT = (
     "You have one tool named `echo`. Call it with the argument "
@@ -617,7 +678,9 @@ def _extract_openai_assistant_choice(
     return msg if isinstance(msg, dict) else None
 
 
-async def _probe_num_ctx(provider: ProviderConfig) -> ProbeResult:
+async def _probe_num_ctx(
+    provider: ProviderConfig, resolved: ResolvedCapabilities
+) -> ProbeResult:
     """v1.0-B Probe — direct detection of Ollama ``num_ctx`` truncation.
 
     Addresses plan.md §9.4 symptom #1 (空応答 / 意味不明応答). Prior to
@@ -683,11 +746,21 @@ async def _probe_num_ctx(provider: ProviderConfig) -> ProbeResult:
     # whatever ``options.num_ctx`` the operator has declared. Request
     # fields win over extra_body, matching the adapter's merge order.
     body: dict[str, Any] = dict(provider.extra_body)
+    # v1.8.2: thinking models burn output tokens on a hidden ``reasoning``
+    # trace before emitting any ``content``. The pre-v1.8.2 default of 32
+    # was tight for any preamble at all; on Gemma 4 26B it caused
+    # ``finish_reason='length'`` with content="" before the canary could
+    # surface, producing a false-positive NEEDS_TUNING.
+    max_tokens = (
+        _NUM_CTX_PROBE_MAX_TOKENS_THINKING
+        if _is_reasoning_model(provider, resolved)
+        else _NUM_CTX_PROBE_MAX_TOKENS_DEFAULT
+    )
     body.update(
         {
             "model": provider.model,
             "messages": [{"role": "user", "content": user_prompt}],
-            "max_tokens": 32,
+            "max_tokens": max_tokens,
             "temperature": 0,
         }
     )
@@ -799,7 +872,9 @@ async def _probe_num_ctx(provider: ProviderConfig) -> ProbeResult:
     )
 
 
-async def _probe_streaming(provider: ProviderConfig) -> ProbeResult:
+async def _probe_streaming(
+    provider: ProviderConfig, resolved: ResolvedCapabilities
+) -> ProbeResult:
     """v1.0-C Probe — streaming completion path integrity.
 
     Addresses plan.md §9.4 symptom #1 from the **output** side. The v1.0-B
@@ -868,11 +943,18 @@ async def _probe_streaming(provider: ProviderConfig) -> ProbeResult:
     # probing. Top-level probe fields win on collision, matching adapter
     # merge order.
     body: dict[str, Any] = dict(provider.extra_body)
+    # v1.8.2: same thinking-model rationale as num_ctx probe — give
+    # reasoning a budget so the visible content has a chance to surface.
+    max_tokens = (
+        _STREAMING_PROBE_MAX_TOKENS_THINKING
+        if _is_reasoning_model(provider, resolved)
+        else _STREAMING_PROBE_MAX_TOKENS_DEFAULT
+    )
     body.update(
         {
             "model": provider.model,
             "messages": [{"role": "user", "content": _STREAMING_PROBE_USER_PROMPT}],
-            "max_tokens": 128,
+            "max_tokens": max_tokens,
             "temperature": 0,
             "stream": True,
         }
@@ -1506,11 +1588,11 @@ async def check_model(
     # declaration probes (tool_calls / thinking / reasoning-leak) should
     # dominate the report — streaming is the output-side sibling of
     # num_ctx and its NEEDS_TUNING verdict is orthogonal to the others.
-    report.results.append(await _probe_num_ctx(provider))
+    report.results.append(await _probe_num_ctx(provider, resolved))
     report.results.append(await _probe_tool_calls(provider, resolved))
     report.results.append(await _probe_thinking(provider, resolved))
     report.results.append(await _probe_reasoning_leak(provider, resolved))
-    report.results.append(await _probe_streaming(provider))
+    report.results.append(await _probe_streaming(provider, resolved))
     return report
 
 

{coderouter_cli-1.8.1 → coderouter_cli-1.8.2}/docs/troubleshooting.md

@@ -282,24 +282,26 @@ profiles:
 
 > **モデル別 tool-call 挙動の深掘り**: Llama-3.3-70B 系の「自然文を tool 呼び出しに変換しがち」性質は、agentic tuning の RLHF signal とシステムプロンプトの相性に起因します。各モデルの傾向と回避策は Unsloth の [Tool calling guide for local LLMs (日本語)](https://unsloth.ai/docs/jp/ji-ben/tool-calling-guide-for-local-llms) が読みやすく、CodeRouter v1.8.0 で導入した `claude_code_suitability` 判定の背景理解にも役立ちます。
 
-### 4-2. ローカル Ollama 経由で踏みやすい既知問題 (v1.8.1 追記)
+### 4-2. ローカル Ollama 経由で踏みやすい既知問題 (v1.8.1 追記、v1.8.2 改訂)
 
-2026-04-26 の実機検証 (M3 Max 32GB / Ollama 0.21.2 / CodeRouter v1.8.0) で、**note 記事や HF で評価が高いモデルでも Ollama 経由では動かないケース**が判明したのでまとめます。
+2026-04-26 の実機検証 (M3 Max 64GB / Ollama 0.21.2 / CodeRouter v1.8.0 → v1.8.2) で、**note 記事や HF で評価が高いモデルでも Ollama 経由では動かないケース**が判明したのでまとめます。
+
+> **v1.8.2 重要更新**: 当初 v1.8.1 で「Qwen3.6 / Gemma 4 ともに num_ctx silent cap」「streaming 0 chars 打ち切り」と判定していた問題は、深掘りの結果 **doctor の `num_ctx` / `streaming` probe が thinking モデルの reasoning トークン消費分を見ていない `max_tokens=32` / `128` バジェットで偽陽性 NEEDS_TUNING を出していた** ことが判明。v1.8.2 で probe バジェットを reasoning モデル時に 1024 まで拡大、registry で `gemma4:*` / `qwen3.6:*` に `thinking: true` 宣言を追加。**Gemma 4 26B は実機で完全動作確定** (`/v1/messages` Anthropic 互換で "Hello." を 2 秒応答)、**Qwen3.6 系の `tool_calls [NEEDS TUNING]` だけが真の課題として残る** (thinking 起因とは別の Ollama tool 仕様未成熟)。
 
 #### 4-2-A. **Qwen3.6:27b / 35b** が Claude Code で実用厳しい
 
-`coderouter doctor --check-model ollama-qwen3-6-27b` の結果：
+v1.8.2 の偽陽性除去後、`coderouter doctor --check-model ollama-qwen3-6-27b` の結果：
 
 | Probe | 結果 | 症状 |
 |---|---|---|
 | auth+basic-chat | OK | 短い chat なら動く |
-| **num_ctx** | **NEEDS_TUNING** | `extra_body.options.num_ctx: 32768` を declare しても canary echo されない (Ollama が silent に縮めてる疑い) |
-| **tool_calls** | **NEEDS_TUNING** | native tool_calls / 修復可能 JSON のいずれも返さず |
-| **streaming** | **NEEDS_TUNING** | `finish_reason='length'` で 0 chars 打ち切り |
+| num_ctx | OK or NEEDS_TUNING (model依存) | thinking バジェット 1024 で偽陽性は解消 |
+| **tool_calls** | **NEEDS_TUNING** ← 残る真の課題 | native tool_calls / 修復可能 JSON のいずれも返さず |
+| streaming | OK or NEEDS_TUNING | thinking バジェット 1024 で偽陽性は解消 |
 
-`/no_think` を `append_system_prompt` に入れても改善せず。Ollama 0.21.2 / llama.cpp 側の Qwen3.6 family 対応がまだ完全でない可能性が高い。
+`/no_think` を `append_system_prompt` に入れても tool_calls は改善せず。Ollama 0.21.2 / llama.cpp 側の Qwen3.6 family の **tool 仕様** がまだ完全でない (chat template / tool スキーマ整合) 可能性が高い。
 
-**回避**: `claude-code-nim` profile の primary に Qwen3.6 を置かず、**Gemma 4 26B または Qwen2.5-Coder 14b を上位に**。bundled `model-capabilities.yaml` も v1.8.1 で `qwen3.6:*` の `claude_code_suitability: ok` を撤回 (declaration 過信の例)。
+**回避**: `claude-code-nim` profile の primary に Qwen3.6 を置かず、**Gemma 4 26B または Qwen2.5-Coder 14b を上位に**。bundled `model-capabilities.yaml` も v1.8.1 で `qwen3.6:*` の `claude_code_suitability: ok` を撤回 (declaration 過信の例)、v1.8.2 で `thinking: true` 追加 (doctor probe 偽陽性除去のため)。
 
 #### 4-2-B. **Qwen3.5 系の HF 蒸留モデル** (Qwopus3.5 等) は llama.cpp 未対応
 
@@ -323,9 +325,13 @@ llama_model_load: error loading model: error loading model architecture:
 
 > **教訓**: HF で「Qwen3.5 + Opus 蒸留」のような新しい組み合わせは note / r/LocalLLaMA で評判が立っていても、**Ollama 経由ですぐ使えるとは限らない**。`ollama pull` → `ollama run` で 500 が出たら、まず Ollama server log で `unknown model architecture` を確認。出たら今は諦めて他のモデルに行くのが時間効率的に正解。
 
-#### 4-2-C. **Gemma 4 26B** は無加工で tool_calls OK
+#### 4-2-C. **Gemma 4 26B** は実機で完全動作 (v1.8.2 で確定)
+
+`coderouter doctor --check-model ollama-gemma4-26b` の `tool_calls` probe が無加工で `[OK]`。v1.8.2 で thinking モデル対応 probe バジェット (1024) を入れた後は **`num_ctx` / `streaming` も `[OK]`** で 6 probe 全クリア。`/v1/messages` Anthropic 互換経由で "Hello." を 2 秒応答 (M3 Max 64GB)、`tool_calls native OK`、`reasoning strip` 動作。
+
+ただし **interactive UX は若干重い** — Gemma 4 は thinking モデルなので `reasoning` フィールドにも応答時間を使う + 26B サイズ + Claude Code の agent loop (1 プロンプトで 3〜6 round-trip) で総応答時間が 30〜90 秒 / プロンプトになる。daily driver には `qwen2.5-coder:14b` のほうが速い。**Gemma 4 は tool_calls native + 高品質が要るときの選択肢**。
 
-同じ実機検証で `coderouter doctor --check-model ollama-gemma4-26b` の `tool_calls` probe が **無加工で `[OK]`**。`num_ctx` / `streaming` は patch (`--apply`) で解消可能。Ollama 経由 Claude Code 用途では **note 記事の「Gemma 4 が日常の王者」評価が裏付けられた**形。v1.8.1 で `coding` profile primary を Gemma 4 / Qwen-Coder 14b へ調整しています。
+note 記事の「Gemma 4 が日常の王者」評価は **Claude Code agentic 用途でも裏付けられた**形。v1.8.1 で `coding` profile primary を Gemma 4 / Qwen-Coder 14b へ調整、v1.8.2 で registry に `thinking: true` を宣言。
 
 #### 4-2-D. ベスト実践 — 「枯れたモデル + 観測ツール」
 
@@ -337,6 +343,20 @@ llama_model_load: error loading model: error loading model architecture:
 4. **新興モデルは慎重に**: HF で見つけた新モデルは Ollama 0.20+ でも未対応のことあり、`ollama run` → server log で確認
 5. **fallback chain で守る**: ローカル primary が落ちても NIM / OpenRouter free に流れるように chain を厚く
 
+#### 4-2-E. doctor probe 自体の限界 — thinking モデル対応 (v1.8.2)
+
+v1.8.2 までの doctor `num_ctx` / `streaming` probe は **`max_tokens=32` / `128`** で出力を要求していた。これは canary token (~5 tokens) や "1..30" (~40 tokens) を返すには十分だったが、**thinking モデル** (Gemma 4、Qwen3 系、gpt-oss、deepseek-r1) は `reasoning` フィールドに思考トークンを吐く設計のため、可視 `content` が出る前に max_tokens に到達して `finish_reason='length'` で打ち切られる **偽陽性 NEEDS_TUNING** を出していた。
+
+v1.8.2 で：
+
+- `_NUM_CTX_PROBE_MAX_TOKENS_DEFAULT = 256` (旧 32)、`_NUM_CTX_PROBE_MAX_TOKENS_THINKING = 1024`
+- `_STREAMING_PROBE_MAX_TOKENS_DEFAULT = 512` (旧 128)、`_STREAMING_PROBE_MAX_TOKENS_THINKING = 1024`
+- `provider.capabilities.thinking` / `provider.capabilities.reasoning_passthrough` / registry の `thinking` / `reasoning_passthrough` のいずれかが true なら thinking バジェットを採用
+
+つまり **provider 宣言不要**: bundled `model-capabilities.yaml` で `gemma4:*` / `qwen3.6:*` などに `thinking: true` を宣言してあれば、user の providers.yaml には何も書かなくても doctor が自動的に正しいバジェットを使う。
+
+**メタ教訓**: diagnostic ツール自身も diagnostic され続ける必要がある (plan.md §5.4 「実機 evidence first」原則の補強)。
+
 ### 4-3. `UserPromptSubmit hook error` が出る (第三者 Claude Code プラグイン)
 
 ```

{coderouter_cli-1.8.1 → coderouter_cli-1.8.2}/pyproject.toml

@@ -11,7 +11,7 @@
 # in plan.md §11.B; once granted, this name will become an alias and
 # `coderouter` will become the canonical distribution name.
 name = "coderouter-cli"
-version = "1.8.1"
+version = "1.8.2"
 description = "Local-first, free-first, fallback-built-in LLM router. Claude Code / OpenAI compatible."
 readme = "README.md"
 requires-python = ">=3.12"

{coderouter_cli-1.8.1 → coderouter_cli-1.8.2}/tests/test_doctor.py

@@ -770,7 +770,169 @@ async def test_num_ctx_request_body_merges_extra_body_options(
     # And the probe's own fields must be present and dominate over any
     # extra_body collisions on top-level keys.
     assert num_ctx_body["model"] == provider.model
-    assert num_ctx_body["max_tokens"] == 32
+    # v1.8.2: default probe budget bumped 32 → 256. Thinking-flagged
+    # models bump further to 1024 (covered by a dedicated test below).
+    # The provider here has no `capabilities.thinking`, so the default
+    # baseline applies.
+    assert num_ctx_body["max_tokens"] == 256
+
+
+@pytest.mark.asyncio
+async def test_num_ctx_max_tokens_bumped_for_thinking_provider_declaration(
+    httpx_mock: HTTPXMock,
+) -> None:
+    """v1.8.2: provider declared ``capabilities.thinking: true`` →
+    num_ctx probe budget is the thinking variant (1024) instead of the
+    256 baseline.
+
+    Thinking models (Gemma 4 26B, Qwen3-with-/think, gpt-oss, deepseek-r1)
+    burn output tokens on a hidden ``reasoning`` trace before any visible
+    ``content`` is emitted. The pre-v1.8.2 default of 32 caused
+    ``finish_reason='length'`` with empty content, producing a
+    false-positive NEEDS_TUNING. Bumping the budget to 1024 gives the
+    reasoning trace + canary echo room to surface.
+    """
+    thinking_caps = Capabilities(thinking=True, tools=True)
+    provider = _oa_provider(
+        name="ollama-gemma4-26b",
+        base_url="http://localhost:11434/v1",
+        model="gemma4:26b",
+        caps=thinking_caps,
+        extra_body={"options": {"num_ctx": 32768}},
+    )
+    captured: list[httpx.Request] = []
+
+    def _capture(request: httpx.Request) -> httpx.Response:
+        captured.append(request)
+        body = json.loads(request.content.decode("utf-8"))
+        if body.get("stream") is True:
+            return httpx.Response(
+                200,
+                content=_sse_stream_count_body(),
+                headers={"content-type": "text/event-stream"},
+            )
+        return httpx.Response(
+            200, json=_openai_ok_response(content=_NUM_CTX_PROBE_CANARY)
+        )
+
+    httpx_mock.add_callback(
+        _capture,
+        url="http://localhost:11434/v1/chat/completions",
+        method="POST",
+        is_reusable=True,
+    )
+    await check_model(
+        _config_for([provider]), provider.name, registry=_empty_registry()
+    )
+    # auth → captured[0], num_ctx → captured[1]
+    num_ctx_body = json.loads(captured[1].content.decode("utf-8"))
+    assert num_ctx_body["max_tokens"] == 1024
+
+
+@pytest.mark.asyncio
+async def test_num_ctx_max_tokens_bumped_when_registry_says_thinking(
+    httpx_mock: HTTPXMock,
+) -> None:
+    """v1.8.2: provider declares no thinking but registry says thinking=true
+    for the (kind, model) → still bump to 1024.
+
+    This mirrors the production path: bundled model-capabilities.yaml
+    declares ``thinking: true`` for ``gemma4:*`` / ``qwen3.6:*`` so
+    operators don't have to repeat the flag in every providers.yaml.
+    """
+    provider = _oa_provider(
+        name="ollama-gemma4-26b",
+        base_url="http://localhost:11434/v1",
+        model="gemma4:26b",
+        # capabilities.thinking left at the default (False)
+        extra_body={"options": {"num_ctx": 32768}},
+    )
+    registry = CapabilityRegistry(
+        [
+            CapabilityRule(
+                match="gemma4:*",
+                kind="openai_compat",
+                capabilities=RegistryCapabilities(thinking=True),
+            )
+        ]
+    )
+    captured: list[httpx.Request] = []
+
+    def _capture(request: httpx.Request) -> httpx.Response:
+        captured.append(request)
+        body = json.loads(request.content.decode("utf-8"))
+        if body.get("stream") is True:
+            return httpx.Response(
+                200,
+                content=_sse_stream_count_body(),
+                headers={"content-type": "text/event-stream"},
+            )
+        return httpx.Response(
+            200, json=_openai_ok_response(content=_NUM_CTX_PROBE_CANARY)
+        )
+
+    httpx_mock.add_callback(
+        _capture,
+        url="http://localhost:11434/v1/chat/completions",
+        method="POST",
+        is_reusable=True,
+    )
+    await check_model(_config_for([provider]), provider.name, registry=registry)
+    num_ctx_body = json.loads(captured[1].content.decode("utf-8"))
+    assert num_ctx_body["max_tokens"] == 1024
+
+
+@pytest.mark.asyncio
+async def test_streaming_max_tokens_bumped_for_thinking_provider(
+    httpx_mock: HTTPXMock,
+) -> None:
+    """v1.8.2: streaming probe also uses the thinking-aware budget — same
+    rationale as num_ctx (reasoning trace burns through the small default).
+
+    Pre-v1.8.2 streaming used ``max_tokens=128`` and Gemma 4 reported
+    ``finish_reason='length'`` after 0 chars of content. Bumping to 1024
+    lets the reasoning prefix + the "1..30" answer fit.
+    """
+    thinking_caps = Capabilities(thinking=True, tools=True)
+    provider = _oa_provider(
+        name="ollama-gemma4-26b",
+        base_url="http://localhost:11434/v1",
+        model="gemma4:26b",
+        caps=thinking_caps,
+        extra_body={"options": {"num_ctx": 32768}},
+    )
+    captured: list[httpx.Request] = []
+
+    def _route(request: httpx.Request) -> httpx.Response:
+        captured.append(request)
+        body = json.loads(request.content.decode("utf-8"))
+        if body.get("stream") is True:
+            return httpx.Response(
+                200,
+                content=_sse_stream_count_body(),
+                headers={"content-type": "text/event-stream"},
+            )
+        return httpx.Response(
+            200, json=_openai_ok_response(content=_NUM_CTX_PROBE_CANARY)
+        )
+
+    httpx_mock.add_callback(
+        _route,
+        url="http://localhost:11434/v1/chat/completions",
+        method="POST",
+        is_reusable=True,
+    )
+    await check_model(
+        _config_for([provider]), provider.name, registry=_empty_registry()
+    )
+    # The streaming probe runs last; identify it by ``stream: true``.
+    stream_bodies = [
+        json.loads(req.content.decode("utf-8"))
+        for req in captured
+        if json.loads(req.content.decode("utf-8")).get("stream") is True
+    ]
+    assert len(stream_bodies) == 1
+    assert stream_bodies[0]["max_tokens"] == 1024
 
 
 @pytest.mark.asyncio
@@ -1767,6 +1929,11 @@ async def test_streaming_request_body_carries_stream_true_and_merges_extra_body(
     }
     # Top-level probe fields must win over any extra_body collision.
     assert streaming_body["model"] == provider.model
+    # v1.8.2: streaming probe baseline budget bumped 128 → 512 to absorb
+    # short stylistic preambles. Thinking models bump further to 1024
+    # (covered by ``test_streaming_max_tokens_bumped_for_thinking_provider``).
+    # Provider here has no thinking declaration, so baseline applies.
+    assert streaming_body["max_tokens"] == 512
 
 
 @pytest.mark.asyncio