Fix: <|think_on|>/<|think_off|> honored from tool responses (prompt-injection surface)

.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+*.pyc
+__pycache__/
+.env

README.md

@@ -6,7 +6,6 @@ tags:
   - qwen
   - qwen3.5
   - qwen3.6
-  - qwen3.8
   - lm-studio
   - mlx
   - llama.cpp
@@ -15,323 +14,226 @@ tags:
   - thinking
 ---
 
-# Fixed jinja chat templates for Qwen 3.5, 3.6 & 3.8 (v22.4)
+# Fixed jinja chat templates for Qwen 3.5 & 3.6 (v20)
 
-This is a universal drop-in Jinja template that fixes rendering errors, KV cache invalidation, token waste, empty think poisoning, and fatal agentic stalling across official Qwen chat templates.
+<details open>
+<summary><b>Update History & Changelog (v20)</b></summary>
 
-It works across LM Studio, llama.cpp, vLLM, MLX, oMLX, KoboldCPP, and any engine that supports Hugging Face Jinja templates. You only need the single `chat_template.jinja` file at the root of this repository for all Qwen 3.5, 3.6, and 3.8 model sizes.
+> **2026-06-05 Update (v20): The Architect Patch.** A monumental structural overhaul targeting deep agentic loops and C++ inference engine compatibility. (1) **Minja AST Flattening:** Dramatically optimized Jinja nesting depths to resolve severe parsing bottlenecks that were dropping inference throughput by 80% on `llama.cpp`. (2) **Minja Replace Bug Fix (Hotfix):** Bypassed a severe C++ parsing bug in `llama.cpp` where using the `replace` filter at index 0 of a user prompt silently dropped the entire text payload. Inline thinking toggles now use `split` and `join` for robust stripping. (3) **Auto-disable Thinking:** Introduced `auto_disable_thinking_with_tools` kwarg (default `false`) that allows users to instantly shut off reasoning blocks during tool use. (4) **Deep Agent Fallbacks:** Resolved exceptions triggered by mid-conversation system prompts or loops lacking human `user` messages. (5) **Payload Truncation:** Implemented `max_tool_arg_chars` and `max_tool_response_chars` configurations to definitively stop context-window explosions from massive data returns. *(Huge thanks to `barubary` / `spiritbuun` for their contributions to these C++ architecture optimizations!)*
 
----
+</details>
 
-## What is New with Qwen 3.8 (v22 / v22.1 / v22.2 / v22.3 / v22.4)
+<details>
+<summary><b>Update History & Changelog (v19)</b></summary>
 
-Qwen 3.8 introduces prompt-steered reasoning depth and new model architectures (`Qwen3.8-2.4T-A95B`, `Qwen3.8-27B`). While the official template added reasoning effort steering, it also introduced several lockdowns, regressions, and syntax crashes.
+> **2026-05-18 Update (v19): The Agentic Loop Cure.** (1) **Abolished "Empty Think" Poisoning:** Rewrote the AST history rendering to completely remove the injection of empty `<think>\n</think>` blocks. This cures a severe in-context learning bias where the model assumed tools could only be called if it didn't think first, which was causing 80%+ of premature `<|im_end|>` turn aborts. (2) **System Prompt Logic Trap Removed:** Softened the absolute tool mandate in the `<IMPORTANT>` block and restored Universal Synthesis instructions. The model is now explicitly permitted to transition from `</think>` to a conversational answer without panicking. (3) **True 100% KV Cache & Amnesia Fix:** `preserve_thinking` now defaults to `true`. Past thoughts are retained chronologically, permanently curing "amnesia stalls" during multi-step tool loops while mathematically guaranteeing 100% KV Cache prefix matching out-of-the-box.
 
-The v22 generation delivers full Qwen 3.8 support with all official bugs resolved:
+</details>
 
-| Feature / Fix | Official Qwen 3.8 Template | This Template (v22.4) |
-|---|---|---|
-| **Default Reasoning Baseline** | Hardcodes `xhigh` by default, often exhausting the token budget on reasoning before generating answers. | Defaults to `medium` (zero injected tokens), preserving KV cache parity with v21 and preventing empty-content timeouts. |
-| **Non-Reasoning Fast Mode** | The `Qwen3.8-2.4T-A95B` template throws a fatal exception if `enable_thinking=false` (the `Qwen3.8-27B` template accepts it). | Full non-reasoning mode restored via kwargs (`enable_thinking=false`, `reasoning_effort="none"`) or inline `<\|think_off\|>`. |
-| **History Reasoning Extraction** | Drops in-content thinking extraction, prepending blank `<think></think>` blocks to real thoughts in chat history. | Extracts reasoning across OpenAI (`reasoning_content`), Anthropic (`thinking`), and in-content tags (`<think>`) without tag duplication. |
-| **Tool Argument Wire Format** | Crashes on serialized JSON strings from standard OpenAI API clients. | Canonical XML default with universal argument handling: safely renders stringified JSON arguments in history without syntax crashes or KV cache invalidation. |
-| **Client Reasoning Aliases** | Rejects non-standard effort names. | Maps OpenAI, Claude Code, Cursor, and Cline aliases automatically: `high`, `max`, `ultracode`, `extreme` $\to$ `xhigh`; `minimal` $\to$ `low`; `none`, `off` $\to$ disabled. |
-| **Inline Chat Tags** | Not supported. | Inline steering via chat text: `<\|think_low\|>`, `<\|think_medium\|>`, `<\|think_xhigh\|>`, `<\|think_ultracode\|>`, `<\|think_off\|>`. Tags are stripped before inference and stay in effect for later turns until another tag replaces them. |
-| **Leading System Prompts** | Treats multiple leading system messages as separate turns. | Merges consecutive leading `system` and `developer` messages into a single system turn joined by double newlines. |
-| **Tool Error Recovery** | Not supported or triggers false warnings on search results containing words like "error". | Two-tier error recovery with smart code/grep disambiguation to avoid false warnings on search results like `throw new Error(...)`. Structural signals escalate on payloads of any size. |
-| **llama.cpp Flag Support** | Requires manual template kwargs. | Native alias support for `--reasoning-preserve` CLI flag via `preserve_reasoning`. |
-| **Diagnostic Tool** | None provided. | Includes `scripts/check_applied.py` to inspect model directories and GGUFs for active template versions. |
+<details>
+<summary><b>Update History & Changelog (v11-v18)</b></summary>
+
+> **2026-05-16 Update (v18): Stability & Precision Patch.** (1) **Bulletproof False-Positive Detection:** Shifted agentic error detection from broad substring matching to strict structural formats (e.g., `"error":`, `Exception:`, `Traceback`), completely curing false-positive retry loops when successful JSON returns simply contain the word "error" or "fail". (2) **Legacy Engine Compatibility:** Replaced `loop.previtem` with explicit array indexing, fixing AST crashes on older `llama.cpp` and `minijinja` builds that do not track loop state items. (3) **True Whitespace Normalization:** Fixed a bug where reasoning bypasses and hallucinated tag recovery stacked hidden multi-newlines (`\n\n\n`), strictly fulfilling the 100% KV Cache hit rate claim for all edge cases. (4) **Code Cleanup:** Removed dead conditional branches during XML tool parsing.
+>
+> **2026-05-15 Update (v17):** Major architecture overhaul resolving edge cases in agentic tooling and KV Cache. (1) **Unified Template:** Consolidated Qwen 3.5 and Qwen 3.6 into a single `chat_template.jinja` file that handles all variants seamlessly. (2) **Fixed "Mutually Exclusive" Stopping Bug:** Changed the history-pruning logic from wiping the entire turn to safely array-slicing out just the raw tool tags (`content.split('<tool_call>')[0]`). This preserves the conversational text in the history, which cures the bug where the model would artificially abort its turn (output `<|im_end|>`) when it wanted to talk and use a tool simultaneously. (3) **100% KV Cache Hit Rate Restoration:** Fully normalized internal whitespace logic (`\n\n` -> `\n`) around think blocks and tool calls to exactly match the model's native autoregressive generation spacing. This perfectly synchronizes the template's rendered history with the cached generated tokens, completely eliminating the severe cache invalidation and full-prompt re-processing issues present in v16.
+>
+> **2026-05-14 Update (v16):** Four-part fix addressing community-reported regressions. (1) **Native XML tool format:** reverted from JSON back to the native `<function=name>` / `<parameter=x>` format the model was trained on, restoring full compatibility with vLLM's `qwen3_coder` parser and all inference engines that implement the Qwen tool protocol. (2) **`--reasoning off` respected in error paths:** when thinking is disabled (`enable_thinking=false` / `--reasoning off`), the error escalation directives are now injected as plain text without opening any `<think>` block, preventing degenerate prompts in no-reasoning sessions. (3) **Smarter false-positive detection:** short shell command results (starting with `$ `) and search results with timing footers (`Took X.Xs`) are now correctly excluded from error detection, preventing tool-retry loops when commands succeed but their output happens to contain the word `error`. (4) **`consecutive_failures` counter no longer resets on assistant messages**, allowing Tier 2 escalation to actually fire across multi-turn tool retry chains.
+>
+> **2026-05-13 Update (v15):** Three-part fix for agentic tool-loop failures. (1) **Two-tier error escalation:** replaced the brittle backwards-lookahead error detection with a fully forward-tracking `last_tool_failed` + `consecutive_failures` counter. On the first error the generation prompt is pre-seeded with a correction directive inside `<think>`; on the 2nd+ consecutive error the think block is bypassed and an out-of-band directive forces an immediate corrected action. (2) **Length-gated detection:** error signals are only read from short tool responses (< 500 chars), preventing false positives when reading code files containing `error`, `exception`, etc. in legitimate content. (3) **Static system prompt:** tool instructions are now fully unconditional, permanently eliminating the KV cache invalidation vector introduced in v14.
+>
+> **2026-05-12 Update (v14):** Cured tool amnesia loops and post-tool overthinking friction! Implemented **Smart Loop Preservation** to dynamically scan subsequent tool returns for error markers and conditionally preserve historical reasoning context during active tool failures. Broadened the system instruction scope to define `<think>` as a dual-purpose planning **or synthesis** space, completely eliminating indecisiveness post-tool retrieval.
+>
+> **2026-05-11 Update (v13):** Radical simplification and compatibility overhaul! Reverted tool schemas and assistant output formatting to standard JSON to natively fix downstream MCP parser crashes and C++ implicit enum coercion bugs. Removed the `ns_scan` history loop to permanently fix KV cache invalidation mid-conversation. Replaced global string replacement for hallucinated tags with a C++ safe, localized array-slicing method to prevent data-corruption on user code blocks.
+>
+> **2026-05-10 Update (v12):** Fixed agent stalls, parameter data-loss, and hallucination bugs! Restored dynamic tool instructions and the `<IMPORTANT>` formatting reminder block to stop grammar parser crashes.
+>
+> **2026-05-10 Update (v11):** Fixed agent looping and overthinking! Re-implemented `preserve_thinking` kwarg to properly strip reasoning blocks from history by default, and restored the reasoning bypass (`<think>\n\n</think>\n\n`).
+
+</details>
+
+This is a drop-in Jinja template that fixes rendering errors, KV cache invalidation, token waste, and fatal agentic stalling in the official Qwen chat templates.
+
+It is tested to work across LM Studio, llama.cpp, vLLM, MLX, oMLX, and any engine that supports HuggingFace Jinja templates.
 
 ---
 
-<details open>
-<summary><b>Quick Install & Engine Setup</b></summary>
+## Why you need this
+The official Qwen templates contain restrictions and Python-specific Jinja logic that break usage on many inference engines and agent frameworks.
+
+Here are the critical issues this template fixes:
+
+| Category | Problem | Impact | Fix |
+|---|---|---|---|
+| **Agentic Loop** | **Premature Stalls (Stopping Bug)** | Model aborts its turn (`<\|im_end\|>`) when trying to combine conversation and a tool call. | Resolved the System Prompt logic trap and cured "Empty Think" poisoning (v19). |
+| **Agentic Loop** | **Retry Stall & Reasoning Spiral** | Model correctly diagnoses a tool error but repeatedly emits the identical failing `<tool_call>`. | Two-tier escalation: seeds `<think>` with correction directive; injects urgent out-of-band directive. |
+| **Agentic Loop** | **Post-Tool Overthinking** | Forced `<think>` block prefilling causes model to panic and debate internal rules after fetching data. | Broadened instructions to define `<think>` as a dual-purpose space for planning *or synthesis*. |
+| **Agentic Loop** | **False-Positive Error Detection** | Short successful API/JSON returns containing the word `error` trigger false retry loops. | Strict structural guards look for exact system failures (`"error":`, `Traceback`, etc.) instead of broad words (v18). |
+| **Performance** | **KV Cache Invalidation** | History pruning dynamically mutates past turns, causing full prompt re-processing every turn. | `preserve_thinking` defaults to `true`, maintaining strict chronological rendering for a 100% KV cache hit rate (v19). |
+| **Performance** | **Empty Think Poisoning** | Stripped past turns leave behind empty `<think></think>` tags, tricking the model into a severe in-context learning bias. | Template completely abolishes the injection of empty think blocks (v19). |
+| **Compatibility** | **Legacy Engine Crashes** | Older C++ parsing engines crash when evaluating `loop.previtem`. | Uses strict chronological array indexing universally supported by all Jinja iterations (v18). |
+| **Compatibility** | **Wrong Tool Call Format** | Qwen-native parsers (like vLLM's `qwen3_coder`) expect XML `<function=name>`. JSON format breaks them. | Restored native XML format while keeping C++ safety. |
+| **Compatibility** | **Jinja C++ Crashes** | Python-specific filters (`map`, `first` on strings) crash on `minijinja`. | All filters replaced with universally compatible equivalents. |
+| **Stability** | **Mid-Conversation System Crash** | Frameworks injecting mid-conversation steering instructions trigger a hard crash. | Native, chronological rendering for system messages anywhere in the history. |
+| **Stability** | **No-User-Query Crash** | `raise_exception` crashes agentic loops or system-only contexts. | Graceful fallback implemented. |
+| **Stability** | **Unclosed Thinking Before Tool** | Model calls a tool without closing its reasoning, bleeding XML tags into tool parsers. | Auto-injects closing tags before tool boundaries securely. |
+| **Edge Cases** | **`developer` Role Rejected** | Modern APIs send the developer role; the official template rejects it. | Added full support for `"developer"`. |
+| **Edge Cases** | **`--reasoning off` Ignored** | When thinking is disabled, tool error escalation still opened a `<think>` block, corrupting the prompt. | Error escalation branches now fully respect `enable_thinking=false`. |
+| **Edge Cases** | **Reasoning Bypass Hallucinations** | When thinking is disabled, Qwen models inherently hallucinate reasoning tags anyway. | Injects a safe boundary to successfully force reasoning bypass without stacking newlines (v18). |
 
-### llama.cpp / llama-server / koboldcpp
-Run `llama-server` with the template file and DeepSeek reasoning format:
-```bash
-llama-server -m your_model.gguf --jinja --chat-template-file chat_template.jinja --reasoning-format deepseek
-```
-*Why `--reasoning-format deepseek` matters:* When connecting coding agents like OpenCode, Claude Code, or Pi.dev to `llama-server`, this flag extracts `<think>` blocks into the dedicated `reasoning_content` API response field. This prevents raw thinking tokens from leaking into the text stream and stopping tool calls midway.
+---
 
-*Native CLI flag:* On recent `llama.cpp` builds, you can pass `--reasoning-preserve` directly for 100% Prefix KV Cache retention.
+## Quick install
+
+Choose your environment and update the template:
 
 ### LM Studio
-1. Open your Qwen model in the right side panel.
+1. Open your Qwen model in the right-side panel.
 2. Scroll down to **Prompt Template**.
 3. Replace the template with the contents of `chat_template.jinja`.
 4. Click **Save**.
 
-### vLLM
-Replace the `"chat_template"` string in your `tokenizer_config.json` with `chat_template_oneline.txt` (or raw `chat_template.jinja`).
+### llama.cpp / koboldcpp
 ```bash
-vllm serve Qwen/Qwen3.8-2.4T-A95B --reasoning-parser qwen3 --tool-call-parser qwen3_xml
+--jinja --chat-template-file chat_template.jinja
 ```
-*Reasoning parser:* Use `--reasoning-parser qwen3` on vLLM to split `<think>` blocks into the response reasoning field. Note that vLLM's parser checks the top-level `enable_thinking: false` request parameter or `reasoning_effort: "none"`, but does not inspect Jinja-internal dynamic `<|think_off|>` tags in prompt bodies. To disable reasoning on vLLM, pass `"enable_thinking": false` in your request parameters.
 
-*Tool parser selection:* Use `--tool-call-parser qwen3_xml` on current vLLM releases. If you are on an older vLLM build, use `--tool-call-parser qwen3_coder`. If you explicitly set `tool_call_format="json"`, use `--tool-call-parser hermes`.
+### vLLM
+Replace the `"chat_template"` string in your `tokenizer_config.json` with the raw file contents. Use the `qwen3_coder` tool parser:
+```bash
+--tool-call-parser qwen3_coder
+```
 
-### oMLX / MLX
-Overwrite `chat_template.jinja` in your local model directory and launch with `--jinja`.
-
-</details>
+### oMLX
+Overwrite `chat_template.jinja` in your local model directory. Load with `--jinja`. Remove any `chat_template_kwargs` overrides because the template handles everything internally.
 
 ---
 
-## Why you need this
+## Which file do I use?
 
-The official Qwen templates contain engine restrictions, Python-specific Jinja logic, and regressions that break local inference and agent workflows.
+Both Qwen 3.5 and Qwen 3.6 variants (including 35B, 32B, 27B, and 14B parameters) have been consolidated. You only need the single `chat_template.jinja` file at the root of the repository.
 
-<details open>
-<summary><b>Critical Issues Fixed</b></summary>
-
-| Area | Issue in Official Templates | The Fix |
-|---|---|---|
-| **Qwen 3.8 Support** | Official 3.8-2.4T-A95B crashes if `enable_thinking=false`. | **Restored Fast Mode**. Supports fast non-reasoning mode via kwargs or `<\|think_off\|>`. |
-| **Qwen 3.8 Token Safety** | Official `xhigh` default burns token budgets with zero content returned. | **Safe `medium` Default**. Zero prompt injection unless explicitly requested. |
-| **Qwen 3.8 Regression** | Official 3.8 injects duplicate blank `<think></think>` in chat history. | **Cured Empty Think Poisoning**. Multi-format reasoning extraction. |
-| **Reasoning Control** | Inability to change reasoning effort in chat interfaces. | **Inline Chat Tags**. Full support for `<\|think_low\|>`, `<\|think_medium\|>`, and `<\|think_xhigh\|>`. |
-| **Compatibility** | `llama.cpp --reasoning-preserve` CLI flag compatibility. | **Native Alias Support**. Supports both `preserve_reasoning` and `preserve_thinking`. |
-| **Compatibility** | JSON-string tool arguments (OpenAI / Ollama) crash official templates. | **Universal Tool Parsing**. Safely handles mappings, JSON strings, and scalar args. |
-| **Agentic Loop** | Model aborts turn when combining conversational text and a tool call. | Cured "Empty Think" poisoning and softened imperative system directives. |
-| **Agentic Loop** | Model gets stuck emitting the identical failing tool call. | Added two-tier error escalation to force correction while retaining reasoning. |
-| **Agentic Loop** | Model panics and debates internal rules after fetching data. | Broadened `<think>` instructions to authorize conversational synthesis. |
-| **Agentic Loop** | API returns containing the word "error" trigger false retry loops. | Replaced broad matching with strict structural guards. |
-| **Performance** | Mutated past turns destroy the prefix cache. | Enforced chronological history for a 100% KV Cache hit rate. |
-| **Performance** | Deep Jinja nesting drops `llama.cpp` speed by 80%. | Flattened the AST architecture to maximize throughput. |
-| **Compatibility** | Python-specific filters crash C++ inference engines. | Rewrote all filters to be 100% `minijinja` safe. |
-| **Compatibility** | Qwen-native parsers (like vLLM) crash on JSON formatting. | Maintained canonical Qwen XML format as the default. |
-| **Compatibility** | Older API setups and wrappers crash on native XML. | Added a `tool_call_format="json"` opt-in override. |
-| **Compatibility** | Anthropic `message.thinking` payloads are rejected. | Added native Anthropic reasoning support. |
-| **Stability** | Massive tool data returns blow out the context window. | Added dynamic payload truncation limits. |
-| **Stability** | Mid-conversation system prompts crash the template. | Added native support for arbitrary system and developer messages. |
-| **Edge Cases** | Text duplicates during streaming generation. | Restored canonical spacing to the generation prompt. |
-| **Edge Cases** | Model hallucinates reasoning tags when thinking is disabled. | Injected strict boundaries to force clean reasoning bypass. |
-
-</details>
+One-line versions (`chat_template_oneline.txt`) are pre-minified for engines that require a single-line template string.
 
 ---
 
-## Customization & Kwarg Reference
+## The thinking toggle
+You can control the model reasoning behavior. Insert `<|think_on|>` or `<|think_off|>` anywhere in your system or user prompt.
 
-<details open>
-<summary><b>1. Reasoning Effort Steering (Qwen 3.8)</b></summary>
-
-Qwen 3.8 has 3 native prompt-steered reasoning levels. You can control this via template kwargs or directly inline in your chat messages:
+The template natively intercepts the tag, removes it from the final context so the model never sees it, and flips the reasoning mode instantly.
 
-**Via Template Kwargs (`chat_template_kwargs`):**
-```json
-{
-  "reasoning_effort": "xhigh"
-}
+**Fast answer, no reasoning:**
+```text
+System: You are a coding assistant. <|think_off|>
+User: What's 2+2?
 ```
-* **`"medium"` (Default / Safe Baseline):** No extra instruction text injected. Preserves 100% Prefix KV Cache parity with v21 and lets the model reason naturally without token-budget traps.
-* **`"xhigh"` (Deep Reasoning):** Injects Qwen's official deep reasoning instruction:
-  > *"Reasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer."*
-* **`"low"` (Concise Reasoning):** Injects concise thinking instructions for fast, summary-oriented reasoning:
-  > *"Reasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration."*
-
-*API Compatibility Aliases:*
-To prevent errors when calling the model through standard API proxies and coding agent harnesses:
-* `"high"`, `"max"`, `"ultracode"`, and `"extreme"` automatically map to `"xhigh"` (supported by OpenAI, Claude Code, Cline, Cursor).
-* `"minimal"` and `"low"` automatically map to `"low"`.
-* `"none"` and `"off"` disable thinking entirely.
 
-**Via Inline Chat Tags (Per-Prompt Steering):**
-* `Solve this proof <|think_xhigh|>` or `<|think_ultracode|>` (Deep reasoning)
-* `Explain recursion briefly <|think_low|>` (Concise reasoning)
-* `What is the capital of France? <|think_off|>` (No reasoning / fast mode)
-
-Tags are sticky: the template scans the whole conversation and the last tag found wins, so a tag in an earlier message stays in effect for later turns until another tag replaces it.
-
-*(Note: When thinking is disabled, reasoning effort instructions are automatically suppressed. On vLLM, prefer request-level `enable_thinking=false` or `reasoning_effort="none"` over `<|think_off|>`; see the vLLM setup notes above).*
+**Deep reasoning:**
+```text
+System: You are a coding assistant. <|think_on|>
+User: Implement a red-black tree in Rust.
+```
+*(The tag syntax uses Qwen's control-token delimiters to guarantee it will never collide with legitimate text or file paths, unlike earlier community templates that used `/think`)*
 
-**Editing defaults without kwargs (LM Studio and other UIs that cannot pass `chat_template_kwargs`):**
-Three variables near the top of `chat_template.jinja` hold the defaults. Edit them before pasting the template:
-* `_default_reasoning_effort = 'medium'` - effort used when no `reasoning_effort` kwarg is passed: `'low'`, `'medium'`, `'xhigh'`, or `'none'` (thinking off). The aliases listed above work too.
-* `enable_thinking = enable_thinking if enable_thinking is defined else true` - change `true` to `false` to default to non-thinking mode.
-* `_tool_format = tool_call_format if tool_call_format is defined else 'xml'` - change `'xml'` to `'json'` for harnesses that need Hermes JSON.
+---
 
-</details>
+## Token Saving: Stripping past thoughts
 
-<details>
-<summary><b>2. KV Cache Preservation (`preserve_reasoning` & `preserve_thinking`)</b></summary>
+By default in v19, this template **preserves** all past `<think>` blocks in the chat history. This is intentional: it prevents the model from suffering "amnesia stalls" during complex, multi-step agentic loops, and it mathematically guarantees a 100% Prefix KV Cache hit rate on local inference engines.
 
-By default, this template **preserves** all past `<think>` blocks in the chat history. This prevents the model from suffering "amnesia stalls" during complex agentic loops and guarantees a 100% Prefix KV Cache hit rate on local inference engines.
+However, if you are running constrained hardware and need to save context tokens, you can explicitly disable this feature in your engine's template kwargs to automatically strip past thoughts:
 
-* On recent `llama.cpp` builds, pass `--reasoning-preserve` directly.
-* Or pass via template kwargs:
 ```json
 {
-  "preserve_thinking": true
+  "preserve_thinking": false
 }
 ```
+*(Note: Setting this to false will naturally reduce your KV Cache hit rate during multi-turn chats, as the prompt string will dynamically mutate).*
 
-If you are on severely memory-constrained hardware and need to save context tokens, set `"preserve_thinking": false` (or `"preserve_reasoning": false`) to strip past thoughts.
+---
 
-> **KV cache trade-off:** `preserve_thinking: false` keeps reasoning only for the turns that follow the most recent user query, so historical thoughts are dropped as soon as a new user turn begins. That rewrites already-rendered history and invalidates the prefix cache from the first assistant turn of the previous segment. The 100% Prefix KV Cache hit rate applies to the default (`true`) setting; enable stripping only when context pressure outweighs prompt reprocessing cost.
+<details>
+<summary>Technical Details of the Critical Fixes</summary>
 
-</details>
+### 1. The "Empty Think" Poisoning & Logic Trap Cure (v19)
+Previous versions attempted to save tokens by replacing past thoughts with empty `<think>\n</think>` blocks, combined with an absolute system prompt demanding a tool be called immediately after `</think>`. This created a toxic in-context learning pattern: the model associated empty thoughts with tools, and full thoughts with forbidden conversational text, causing an 80%+ premature `<|im_end|>` stalling rate. v19 abolishes empty think injection and rewrites the `<IMPORTANT>` directives to explicitly authorize conversational synthesis after a thought block.
+
+### 2. KV Cache Safety & Autoregressive Normalization (v18/v19)
+Llama.cpp and vLLM utilize prefix KV caching to speed up generation. Because v19 now preserves historical thoughts chronologically by default, the rendered history perfectly synchronizes with the cached generated tokens. Combined with strict single `\n` normalization at autoregressive boundaries, this achieves a 100% KV Cache hit rate in multi-turn loops.
+
+### 3. Native XML Tool Call Format (v16)
+The model was trained with the XML-based tool call format used by Qwen3-Coder:
+```xml
+<tool_call>
+<function=tool_name>
+<parameter=param_name>
+value
+</parameter>
+</function>
+</tool_call>
+```
+v16 restored this format natively, making it compatible with all parsers while bypassing the `|items` crash by using C++ safe key iteration (`for args_name in tool_call.arguments`).
 
-<details>
-<summary><b>3. Tool Call Format (XML vs JSON)</b></summary>
+### 4. Two-Tier Agentic Error Escalation (v15)
+When a tool call fails validation repeatedly, the model can enter a degenerate reasoning spiral. This template leverages a two-tier escalation system driven by a forward-tracked `consecutive_failures` counter:
+- **Tier 1 (1st error):** Generation prompt prefix changes to seed reasoning at a different token position, breaking the cached attractor state.
+- **Tier 2 (2nd+ consecutive errors):** Think block bypassed entirely. An urgent out-of-band directive forces an immediate corrected action wrapped safely within the user `tool_response` block.
 
-Qwen models are natively trained on XML tool calls (`<function=name>`). By default, this template uses **`xml`** format:
-* **`"xml"` (Default):** Generates canonical XML instructions for tool calls and safely handles both dictionary arguments and serialized JSON strings in assistant history without corrupting XML tags or mutating system prompts between turns. Dictionary arguments render as `<parameter=...>` blocks; a serialized JSON string is rendered verbatim inside the `<function=...>` block as a best-effort fallback (Jinja cannot parse JSON), so dictionaries are preferred. vLLM converts string arguments to dictionaries before rendering, so it always takes the `<parameter>` path.
-* **`"json"` (Optional Override):** Forces Hermes JSON format (`{"name": "...", "arguments": {...}}`) for both system prompt instructions and history rendering.
+### 5. Smart False-Positive Detection (v18)
+Instead of broad substring matching that triggers false retry-loops on successful database returns containing words like "error", v18 utilizes strict structural guards looking for `Exception:`, `"error":`, `Traceback`, and `command not found`, combined with length gates and shell-echo exclusions (`$ `).
 
-**When to use the JSON override:**
-If you are using a framework or harness (such as specific Hermes Agent configurations) that strictly requires Hermes JSON, pass:
-```json
-{
-  "tool_call_format": "json"
-}
-```
-*(When opting into JSON format, both argument and tool response truncation are bypassed to avoid corrupting JSON syntax)*.
+### 6. minijinja Compatibility Constraints (v18/v20)
+Python-only Jinja2 features crash or misbehave on `minijinja`/`minja` (the C++ runtime used by llama.cpp, LM Studio, and MLX). All instances have been refactored for universal support:
+- `content | replace('<|think_on|>', '')` -> `content.split('<|think_on|>') | join('')` (Fixes a severe bug where `minja` silently drops the entire text payload if the replaced string is found at index 0).
+- `\| items` -> `for key in mapping`
+- `loop.previtem` -> `messages[loop.index0 - 1]`
+- `map('string')` -> `join('|')`
+- `\| first` -> `'$ ' in content`
 
 </details>
 
 <details>
-<summary><b>4. Dynamic Payload Truncation</b></summary>
-
-To prevent oversized tool returns from blowing out context limits:
-* `max_tool_arg_chars` (default `0` / disabled): Slices oversized tool call arguments. Applies to mapping arguments and to serialized JSON string arguments alike.
-* `max_tool_response_chars` (default `0` / disabled): Slices oversized tool output data.
-
-Both limiters are disabled automatically when `tool_call_format="json"` is active, since slicing serialized JSON corrupts the payload for downstream parsers.
+<summary>Comparison Matrix: Official vs Fixed vs Community</summary>
+
+| Feature | Official Qwen Templates | LuffyTheFox | mod-ellary | Pneuny | **This Fixed Template (v19)** |
+|---------|----------|-------------|------------|--------|----------------|
+| Tool call format | XML (native) | JSON | JSON | JSON | **XML (native, qwen3_coder compatible)** |
+| Tool arguments | Fails (`\|items`) | Fixed | Missing | Fixed | **Fixed (C++ safe XML)** |
+| Premature Stalls (Stopping Bug) | Stalls | Stalls | Stalls | Stalls | **Fixed via Logic Trap / Poisoning removal (v19)** |
+| Agentic Retry Stall & Reasoning Spiral | Stalls | Stalls | Stalls | Stalls | **Two-tier escalation system** |
+| False-positive tool errors | N/A | N/A | N/A | N/A | **Guarded (Strict structural matching)** |
+| Post-Tool Overthinking | Spams/Stalls | Broken | Broken | Broken | **Universal Synthesis** |
+| `--reasoning off` on tool errors | N/A | N/A | N/A | N/A | **Fully respected** |
+| `developer` role | Missing | Missing | Missing | Missing | **Added** |
+| Thinking toggle | None | None | `/think` (system only) | None | **`<\|think_off\|>` anywhere** |
+| Empty think in history | Spams empty blocks | Broken | Tags omitted | Broken | **Abolished completely (v19)** |
+| KV prefix caching | Breaks on dynamic history | Breaks | Breaks | Breaks | **100% stable out-of-the-box (v19)** |
+| Mid-conversation system | Crashes | Crashes | Crashes | Crashes | **Fixed** |
+| No-user-query crash | Crashes | Crashes | Crashes | Crashes | **Graceful fallback** |
+| Legacy AST support | Fails (`previtem`) | Fails | Fails | Fails | **Fixed (`index0`)** |
+| `</thinking>` hallucination | Fails | N/A | N/A | N/A | **Detected and safely trimmed** |
 
 </details>
 
 ---
 
-<details>
-<summary><b>Diagnostic Script & Test Suite</b></summary>
-
-### Check Active Template on Your Model
-Run the included diagnostic utility on your model folder or GGUF:
-```bash
-python3 scripts/check_applied.py /path/to/your/model
-```
+## Running the test suite
 
-### Running the Test Suite
 ```bash
-python3 scripts/test_v22.py
+python3 scripts/test_v20.py
 ```
-Tests cover 101 automated verification cells including `reasoning_effort` levels, monotonic API mappings, inline chat tags, multi-part and vision payloads, tool call serialization across wire formats, dynamic truncation, error escalation precision, malformed input handling, multi-turn history parsing, prefix KV cache stability, and parity between `chat_template.jinja` and `chat_template_oneline.txt`. Set `QWEN_TEMPLATE_FILE=chat_template_oneline.txt` to run the entire suite against the minified build. Test 101 is a deterministic property fuzzer (`scripts/fuzz_template.py`) asserting nine structural invariants over generated conversations; run it standalone with `python3 scripts/fuzz_template.py --cases 2000`.
 
-</details>
+Tests cover: `auto_disable_thinking_with_tools`, payload truncation logic, parallel tool spacing, mid-conversation system rendering, deep agent loop fallback, XML tool format, `<|think_off|>` / `<|think_on|>` inline overrides, and all legacy v19 regression tests.
 
 ---
 
-## Authorship & Contributors
-| Role | Author / Contributor |
-|------|----------------------|
+## Authorship
+
+| Role | Author |
+|------|--------|
 | Original models | Alibaba Cloud (Qwen team) |
-| Template fixes | [Frédéric Guigand](https://huggingface.co/froggeric) (`@froggeric`) |
-| Property fuzzer, error tiering & test suite | [Juan Calderon-Perez](https://huggingface.co/g-a-b-y) (`@g-a-b-y`) |
-| Multi-tool alignment, reasoning fields & docs | [Gabriel Devenyi](https://huggingface.co/gdevenyi) (`@gdevenyi`) |
+| Template fixes | [froggeric](https://huggingface.co/froggeric) |
 | C++ AST optimizations | [barubary](https://github.com/spiritbuun/buun-llama-cpp) / `spiritbuun` |
 
 ## License
-Apache-2.0, inherited from Qwen.
-
----
 
-<details>
-<summary>Technical Details of the Critical Fixes</summary>
-
-### 1. The "Empty Think" Poisoning and Logic Trap Cure
-Previous templates attempted to save tokens by replacing past thoughts with empty `<think>\n</think>` blocks, combined with an absolute system prompt demanding a tool be called immediately after `</think>`. This created a toxic pattern where the model associated empty thoughts with tools, causing an 80%+ premature turn abort rate. We abolished empty think injection and rewrote the `<IMPORTANT>` directives to explicitly authorize conversational synthesis after thinking. In this release, we also cured official Qwen 3.8's history bug where missing in-content parsers created duplicate blank think tags.
-
-### 2. Upfront Pre-Scan for Control Tags & Inline Effort Steering
-In Jinja templates, system prompts are assembled before iterating over message history. We introduce an upfront pre-scan covering raw strings, string lists, and multi-part content lists (`[{'type': 'text', 'text': '...'}]`). This resolves `<|think_off|>`, `<|think_on|>`, `<|think_low|>`, `<|think_medium|>`, and `<|think_xhigh|>` states before the system message is built, preventing reasoning instructions from being injected into non-reasoning turns and cleanly stripping all tags during rendering.
-
-### 3. KV Cache Safety and Autoregressive Normalization
-Llama.cpp and vLLM utilize prefix KV caching to speed up generation. Because this template preserves historical thoughts chronologically by default and defaults `reasoning_effort` to `medium` (zero system tokens), rendered history perfectly synchronizes with cached generated tokens. Combined with strict single newline normalization at autoregressive boundaries, this achieves a 100% KV Cache hit rate in multi-turn sessions.
-
-### 4. Native XML Tool Format and Universal Serialization
-The model was trained with the XML tool format used by Qwen3-Coder. We restored this format natively while bypassing the `|items` crash by handling both mapping dictionaries and JSON strings. This eliminates crashes when standard OpenAI proxies pass stringified arguments.
-
-### 5. Two-Tier Agentic Error Escalation
-When a tool call fails validation repeatedly, the model can enter a degenerate reasoning spiral. This template leverages a two-tier escalation system driven by a forward-tracked `consecutive_failures` counter. On the first error, a diagnostic warning is injected. On the second consecutive error, an urgent system warning forces a fundamentally different approach while retaining the reasoning block so the model can plan its correction.
-
-### 6. Smart False-Positive Detection
-Instead of broad substring matching that triggers false retry loops on successful database returns containing words like "error", this template utilizes strict structural guards evaluated over the first 120 characters of the payload.
-
-Signals are split into two tiers. **Strong signals** are unambiguous structural markers (`"error":`, `Traceback (most recent call last):`, `command not found`, `Exception:`, `fatal:`, nonzero exit codes, `invalid syntax`) and fire unconditionally. **Weak signals** are bare prefixes (`error:`, `err!`) and remain gated by a length ceiling plus shell echo (`$ `) and timing (`took `) exclusions. Code and search results are excluded up front via `throw new`, `console.error`, `logger.error` and similar patterns.
-
-Tiering matters because the earlier flat gate suppressed every signal on payloads of 600 characters or more: a routine multi-frame Python traceback exceeds that ceiling, and any output echoing a shell prompt or a timing figure was discarded outright. Strong signals now escalate regardless of payload size.
-
-### 7. minijinja Compatibility Constraints
-Python-only Jinja2 features crash or misbehave on `minijinja` (the C++ runtime used by llama.cpp, LM Studio, and MLX). All instances have been refactored for universal support:
-* `content | replace('<|think_on|>', '')` became `content.split('<|think_on|>') | join('')` (fixes a bug where `minja` silently drops the entire text payload if the replaced string is found at index 0).
-* `| items` became `mapping.items()` iteration, which `minijinja` implements natively.
-* `loop.previtem` became explicit array indexing.
-* `map('string')` became `join('|')`.
-* `| first` became `'$ ' in content`.
-
-### 8. AST Flattening for C++ Throughput
-Deeply nested Jinja loops and macros create severe parsing bottlenecks in C++ inference engines. We flattened the AST architecture, effectively curing an 80% inference throughput drop on `llama.cpp` by streamlining how `ns_state` tracking and historical rendering loops are evaluated.
-
-### 9. Dynamic Payload Truncation
-Massive API or database returns can instantly blow out a model's context window. We implemented `max_tool_arg_chars` and `max_tool_response_chars` limiters that safely slice oversized payloads. Argument truncation covers both mapping arguments and serialized JSON string arguments, so the OpenAI proxy wire format is limited on the same terms as native dictionaries. Both limiters are automatically disabled when `tool_call_format="json"` is active, as slicing serialized JSON structurally corrupts the data and crashes downstream parsers.
-
-### 10. Reasoning Bypass Hallucination Mitigation
-When thinking is disabled, Qwen models often hallucinate reasoning tags due to their training bias. We injected a safe boundary and adjusted the `<IMPORTANT>` system block to remove explicit mentions of `</think>` during tool instructions. This stops the model from hallucinating closing tags when calling tools in a no-reasoning state.
-
-</details>
-
----
-
-<details>
-<summary>Update History & Changelog</summary>
-
-> **2026-08-24 Update (v22.4): Multi-Tool Token Parity, Extended Reasoning Formats, and UI Default Knobs.**
-> 1. **Parallel Tool Call Token Parity:** Consecutive `<tool_call>` blocks in assistant history are now separated by a single newline (`\n`) instead of double newlines (`\n\n`), restoring exact token alignment with official Qwen model generation and preventing prefix KV cache divergence during multi-tool turns (#87).
-> 2. **vLLM & Responses API Reasoning Support:** Added native support for `message.reasoning` (used by vLLM OpenAI-compatible endpoints and Responses API schemas) alongside `reasoning_content` and `thinking` (#88).
-> 3. **Top-Level `_default_reasoning_effort` Knob:** Added an explicit `_default_reasoning_effort` configuration variable at the top of the template and removed dead assignment code, allowing LM Studio and WebUI users who cannot pass kwargs to change the default reasoning level cleanly without template errors (#91).
-> 4. **Documented Sticky Inline Tags & UI Configuration:** Documented inline tag persistence across turns, string-argument fallbacks in XML, and clarified vLLM launch commands (`--reasoning-parser qwen3` alongside `--tool-call-parser qwen3_xml`) (#89, #90).
-> 5. **Expanded Test Suite (101 -> 102):** Added automated test coverage for `message.reasoning` extraction, `_default_reasoning_effort` knob behavior, and updated parallel tool call assertions.
->
-> *(Credits: Huge thanks to Gabriel Devenyi (@gdevenyi) for their contributions to the v22.4 release!)*
->
-> **2026-08-20 Update (v22.3): Error Detection Tiering, Reasoning De-duplication, and Test Suite Expansion.**
-> 1. **Two-Tier Error Signals:** Structural error markers now escalate regardless of payload size. The previous flat 600-character ceiling plus whole-body `$ ` and `took ` exclusions silently suppressed warnings on ordinary multi-frame tracebacks and on any shell transcript that echoed its command. Successful exit-code reports (`Exit code: 0`) and JSON success envelopes (`"error": null` / `false` / `""`) are excluded from the strong tier so success payloads do not escalate.
-> 2. **Reasoning De-duplication:** When `reasoning_content` or `thinking` is supplied, a leading think block in `content` is stripped so clients that populate both no longer emit two consecutive think blocks. Literal tags later in the answer (for example inside code fences) are preserved verbatim; full heuristic extraction still applies when no explicit reasoning field is present.
-> 3. **Single-Line Think Blocks:** `<think>...</think>` written without surrounding newlines is now extracted instead of leaking raw tags into rendered history.
-> 4. **Complete Argument Serialization:** Scalar and list tool arguments are serialized via `| tojson` rather than silently dropped, in both XML and JSON wire formats.
-> 5. **Consistent Truncation:** `max_tool_arg_chars` now applies to serialized JSON string arguments, and `max_tool_response_chars` is bypassed under `tool_call_format="json"` as documented.
-> 6. **KV Cache Documentation:** Documented that `preserve_thinking: false` rewrites rendered history at each new user turn and therefore voids the prefix cache guarantee, which applies to the default setting.
-> 7. **Test Suite Expansion (44 -> 101):** Added coverage for control tag and alias completeness, malformed input and exception paths, vision payloads, agentic wire-format shapes, reasoning extraction variants, error detection precision, prefix KV cache stability, and jinja/oneline build parity.
-> 8. **Property-Based Fuzz Harness:** Added `scripts/fuzz_template.py`, a deterministic conversation generator asserting nine structural invariants (render success, jinja/oneline parity, token balance, verbatim content preservation, XML parameter fidelity, JSON tool-call validity, warning precision, prefix KV stability, no-think prefill). Prefix stability is checked at generation boundaries: merged system blocks and consecutive tool-result batches are atomic, since the model only generates after a full batch is appended.
->
-> *(Credits: Huge thanks to Juan Calderon-Perez (@g-a-b-y) for their massive contributions to the v22.3 release, including the property-based fuzz harness, the two-tier error signal architecture, and extensive test coverage!)*
->
-> **2026-08-19 Update (v22.2): Extended Effort Aliases, String Argument Safety, and Error Disambiguation.**
-> 1. **Universal Tool Argument Handling:** Hardened XML tool argument parsing to safely handle both mappings and serialized JSON strings in assistant history without syntax crashes or KV cache mutation.
-> 2. **Reasoning Effort Aliases:** Added `"ultracode"` and `"extreme"` mappings to `'xhigh'`, with inline `<|think_ultracode|>` and `<|think_extreme|>` support (#78).
-> 3. **Multi-System Message Merging:** Merged consecutive leading `system` and `developer` messages into a single unified system turn with `\n\n`.
-> 4. **Grep / Search Error Disambiguation:** Eliminated false-positive tool error warnings on code search results containing patterns like `throw new Error` or `console.error` (#66).
-> 5. **Safe XML Primitive Serialization:** Boolean and null XML parameter values now serialize to `true`, `false`, and `null` via `| tojson`.
-> 6. **Zero-Crash Resilience:** Maintained full resilience without fatal `raise_exception` aborts across all runtime engines.
-
-> **2026-08-16 Update (v22.1): The Qwen 3.8 Update (Bounded Reasoning Defaults, Inline Chat Tags, and Diagnostic Utility).**
-> 1. **Full Qwen 3.8 Support:** Single drop-in template covering all Qwen 3.5, 3.6, and 3.8 model variants (`Qwen3.8-2.4T-A95B`, `Qwen3.8-27B`).
-> 2. **Default `reasoning_effort` to `medium`:** Replaced the unsafe `xhigh` default with `medium` (zero injected tokens). Eliminates the runaway reasoning token-burn failure where models explore branches until hitting `max_tokens` with empty content (#72).
-> 3. **Inline Chat Tags:** Added support for `<|think_low|>`, `<|think_medium|>`, and `<|think_xhigh|>` tags directly inside chat messages (#70).
-> 4. **API Mapping & Aliasing:** Added case-insensitive alias support for client and serving runtimes (`high`/`max` -> `xhigh`, `minimal` -> `low`, `none` -> thinking off).
-> 5. **Sequential Control Tag Stripping:** All 7 control tags are cleanly stripped across system, user, and multi-part content without prompt leakage.
-> 6. **Cured Official 3.8 Empty Think Bug:** Fixed a regression in the official Qwen 3.8 template where removing `<think>` extraction caused blank `<think></think>` blocks to be prepended to real thoughts in chat history.
-> 7. **Restored Fast Mode:** Replaced official 3.8's hard exception on `enable_thinking=false`, restoring full user freedom to disable reasoning via kwargs or `<|think_off|>`.
-> 8. **Universal Tool Arguments:** Hardened tool call parsing to handle both dictionary structures and JSON-serialized strings without crashing.
-> 9. **Diagnostic Utility:** Added `scripts/check_applied.py` to inspect model folders and GGUFs for template consistency.
-
-> **2026-08-13 Update (v22): Qwen 3.8 Support, Reasoning Effort Controls, and Engine Hardening.** 
-
-> **2026-07-02 Update (v21.3): Optional JSON Tool Format Kwarg.** Added an optional `tool_call_format="json"` override for `chat_template_kwargs`.
-
-> **2026-07-02 Update (v21.2): Reasoning Bypass Hallucination Fix.** Adjusted `<IMPORTANT>` block instructions to remove explicit mentions of `</think>` during tool definitions.
-
-> **2026-07-02 Update (v21.1): Reliability Overhaul & XML Revert.** Reverted to native XML format for vLLM `qwen3_coder` compatibility and restored `preserve_thinking` default to `true`.
-
-</details>
+Apache-2.0, inherited from Qwen.

archive/README-v20.md

@@ -1,239 +0,0 @@
----
-license: apache-2.0
-tags:
-  - jinja
-  - chat-template
-  - qwen
-  - qwen3.5
-  - qwen3.6
-  - lm-studio
-  - mlx
-  - llama.cpp
-  - vllm
-  - tool-calling
-  - thinking
----
-
-# Fixed jinja chat templates for Qwen 3.5 & 3.6 (v20)
-
-<details open>
-<summary><b>Update History & Changelog (v20)</b></summary>
-
-> **2026-06-05 Update (v20): The Architect Patch.** A monumental structural overhaul targeting deep agentic loops and C++ inference engine compatibility. (1) **Minja AST Flattening:** Dramatically optimized Jinja nesting depths to resolve severe parsing bottlenecks that were dropping inference throughput by 80% on `llama.cpp`. (2) **Minja Replace Bug Fix (Hotfix):** Bypassed a severe C++ parsing bug in `llama.cpp` where using the `replace` filter at index 0 of a user prompt silently dropped the entire text payload. Inline thinking toggles now use `split` and `join` for robust stripping. (3) **Auto-disable Thinking:** Introduced `auto_disable_thinking_with_tools` kwarg (default `false`) that allows users to instantly shut off reasoning blocks during tool use. (4) **Deep Agent Fallbacks:** Resolved exceptions triggered by mid-conversation system prompts or loops lacking human `user` messages. (5) **Payload Truncation:** Implemented `max_tool_arg_chars` and `max_tool_response_chars` configurations to definitively stop context-window explosions from massive data returns. *(Huge thanks to `barubary` / `spiritbuun` for their contributions to these C++ architecture optimizations!)*
-
-</details>
-
-<details>
-<summary><b>Update History & Changelog (v19)</b></summary>
-
-> **2026-05-18 Update (v19): The Agentic Loop Cure.** (1) **Abolished "Empty Think" Poisoning:** Rewrote the AST history rendering to completely remove the injection of empty `<think>\n</think>` blocks. This cures a severe in-context learning bias where the model assumed tools could only be called if it didn't think first, which was causing 80%+ of premature `<|im_end|>` turn aborts. (2) **System Prompt Logic Trap Removed:** Softened the absolute tool mandate in the `<IMPORTANT>` block and restored Universal Synthesis instructions. The model is now explicitly permitted to transition from `</think>` to a conversational answer without panicking. (3) **True 100% KV Cache & Amnesia Fix:** `preserve_thinking` now defaults to `true`. Past thoughts are retained chronologically, permanently curing "amnesia stalls" during multi-step tool loops while mathematically guaranteeing 100% KV Cache prefix matching out-of-the-box.
-
-</details>
-
-<details>
-<summary><b>Update History & Changelog (v11-v18)</b></summary>
-
-> **2026-05-16 Update (v18): Stability & Precision Patch.** (1) **Bulletproof False-Positive Detection:** Shifted agentic error detection from broad substring matching to strict structural formats (e.g., `"error":`, `Exception:`, `Traceback`), completely curing false-positive retry loops when successful JSON returns simply contain the word "error" or "fail". (2) **Legacy Engine Compatibility:** Replaced `loop.previtem` with explicit array indexing, fixing AST crashes on older `llama.cpp` and `minijinja` builds that do not track loop state items. (3) **True Whitespace Normalization:** Fixed a bug where reasoning bypasses and hallucinated tag recovery stacked hidden multi-newlines (`\n\n\n`), strictly fulfilling the 100% KV Cache hit rate claim for all edge cases. (4) **Code Cleanup:** Removed dead conditional branches during XML tool parsing.
->
-> **2026-05-15 Update (v17):** Major architecture overhaul resolving edge cases in agentic tooling and KV Cache. (1) **Unified Template:** Consolidated Qwen 3.5 and Qwen 3.6 into a single `chat_template.jinja` file that handles all variants seamlessly. (2) **Fixed "Mutually Exclusive" Stopping Bug:** Changed the history-pruning logic from wiping the entire turn to safely array-slicing out just the raw tool tags (`content.split('<tool_call>')[0]`). This preserves the conversational text in the history, which cures the bug where the model would artificially abort its turn (output `<|im_end|>`) when it wanted to talk and use a tool simultaneously. (3) **100% KV Cache Hit Rate Restoration:** Fully normalized internal whitespace logic (`\n\n` -> `\n`) around think blocks and tool calls to exactly match the model's native autoregressive generation spacing. This perfectly synchronizes the template's rendered history with the cached generated tokens, completely eliminating the severe cache invalidation and full-prompt re-processing issues present in v16.
->
-> **2026-05-14 Update (v16):** Four-part fix addressing community-reported regressions. (1) **Native XML tool format:** reverted from JSON back to the native `<function=name>` / `<parameter=x>` format the model was trained on, restoring full compatibility with vLLM's `qwen3_coder` parser and all inference engines that implement the Qwen tool protocol. (2) **`--reasoning off` respected in error paths:** when thinking is disabled (`enable_thinking=false` / `--reasoning off`), the error escalation directives are now injected as plain text without opening any `<think>` block, preventing degenerate prompts in no-reasoning sessions. (3) **Smarter false-positive detection:** short shell command results (starting with `$ `) and search results with timing footers (`Took X.Xs`) are now correctly excluded from error detection, preventing tool-retry loops when commands succeed but their output happens to contain the word `error`. (4) **`consecutive_failures` counter no longer resets on assistant messages**, allowing Tier 2 escalation to actually fire across multi-turn tool retry chains.
->
-> **2026-05-13 Update (v15):** Three-part fix for agentic tool-loop failures. (1) **Two-tier error escalation:** replaced the brittle backwards-lookahead error detection with a fully forward-tracking `last_tool_failed` + `consecutive_failures` counter. On the first error the generation prompt is pre-seeded with a correction directive inside `<think>`; on the 2nd+ consecutive error the think block is bypassed and an out-of-band directive forces an immediate corrected action. (2) **Length-gated detection:** error signals are only read from short tool responses (< 500 chars), preventing false positives when reading code files containing `error`, `exception`, etc. in legitimate content. (3) **Static system prompt:** tool instructions are now fully unconditional, permanently eliminating the KV cache invalidation vector introduced in v14.
->
-> **2026-05-12 Update (v14):** Cured tool amnesia loops and post-tool overthinking friction! Implemented **Smart Loop Preservation** to dynamically scan subsequent tool returns for error markers and conditionally preserve historical reasoning context during active tool failures. Broadened the system instruction scope to define `<think>` as a dual-purpose planning **or synthesis** space, completely eliminating indecisiveness post-tool retrieval.
->
-> **2026-05-11 Update (v13):** Radical simplification and compatibility overhaul! Reverted tool schemas and assistant output formatting to standard JSON to natively fix downstream MCP parser crashes and C++ implicit enum coercion bugs. Removed the `ns_scan` history loop to permanently fix KV cache invalidation mid-conversation. Replaced global string replacement for hallucinated tags with a C++ safe, localized array-slicing method to prevent data-corruption on user code blocks.
->
-> **2026-05-10 Update (v12):** Fixed agent stalls, parameter data-loss, and hallucination bugs! Restored dynamic tool instructions and the `<IMPORTANT>` formatting reminder block to stop grammar parser crashes.
->
-> **2026-05-10 Update (v11):** Fixed agent looping and overthinking! Re-implemented `preserve_thinking` kwarg to properly strip reasoning blocks from history by default, and restored the reasoning bypass (`<think>\n\n</think>\n\n`).
-
-</details>
-
-This is a drop-in Jinja template that fixes rendering errors, KV cache invalidation, token waste, and fatal agentic stalling in the official Qwen chat templates.
-
-It is tested to work across LM Studio, llama.cpp, vLLM, MLX, oMLX, and any engine that supports HuggingFace Jinja templates.
-
----
-
-## Why you need this
-The official Qwen templates contain restrictions and Python-specific Jinja logic that break usage on many inference engines and agent frameworks.
-
-Here are the critical issues this template fixes:
-
-| Category | Problem | Impact | Fix |
-|---|---|---|---|
-| **Agentic Loop** | **Premature Stalls (Stopping Bug)** | Model aborts its turn (`<\|im_end\|>`) when trying to combine conversation and a tool call. | Resolved the System Prompt logic trap and cured "Empty Think" poisoning (v19). |
-| **Agentic Loop** | **Retry Stall & Reasoning Spiral** | Model correctly diagnoses a tool error but repeatedly emits the identical failing `<tool_call>`. | Two-tier escalation: seeds `<think>` with correction directive; injects urgent out-of-band directive. |
-| **Agentic Loop** | **Post-Tool Overthinking** | Forced `<think>` block prefilling causes model to panic and debate internal rules after fetching data. | Broadened instructions to define `<think>` as a dual-purpose space for planning *or synthesis*. |
-| **Agentic Loop** | **False-Positive Error Detection** | Short successful API/JSON returns containing the word `error` trigger false retry loops. | Strict structural guards look for exact system failures (`"error":`, `Traceback`, etc.) instead of broad words (v18). |
-| **Performance** | **KV Cache Invalidation** | History pruning dynamically mutates past turns, causing full prompt re-processing every turn. | `preserve_thinking` defaults to `true`, maintaining strict chronological rendering for a 100% KV cache hit rate (v19). |
-| **Performance** | **Empty Think Poisoning** | Stripped past turns leave behind empty `<think></think>` tags, tricking the model into a severe in-context learning bias. | Template completely abolishes the injection of empty think blocks (v19). |
-| **Compatibility** | **Legacy Engine Crashes** | Older C++ parsing engines crash when evaluating `loop.previtem`. | Uses strict chronological array indexing universally supported by all Jinja iterations (v18). |
-| **Compatibility** | **Wrong Tool Call Format** | Qwen-native parsers (like vLLM's `qwen3_coder`) expect XML `<function=name>`. JSON format breaks them. | Restored native XML format while keeping C++ safety. |
-| **Compatibility** | **Jinja C++ Crashes** | Python-specific filters (`map`, `first` on strings) crash on `minijinja`. | All filters replaced with universally compatible equivalents. |
-| **Stability** | **Mid-Conversation System Crash** | Frameworks injecting mid-conversation steering instructions trigger a hard crash. | Native, chronological rendering for system messages anywhere in the history. |
-| **Stability** | **No-User-Query Crash** | `raise_exception` crashes agentic loops or system-only contexts. | Graceful fallback implemented. |
-| **Stability** | **Unclosed Thinking Before Tool** | Model calls a tool without closing its reasoning, bleeding XML tags into tool parsers. | Auto-injects closing tags before tool boundaries securely. |
-| **Edge Cases** | **`developer` Role Rejected** | Modern APIs send the developer role; the official template rejects it. | Added full support for `"developer"`. |
-| **Edge Cases** | **`--reasoning off` Ignored** | When thinking is disabled, tool error escalation still opened a `<think>` block, corrupting the prompt. | Error escalation branches now fully respect `enable_thinking=false`. |
-| **Edge Cases** | **Reasoning Bypass Hallucinations** | When thinking is disabled, Qwen models inherently hallucinate reasoning tags anyway. | Injects a safe boundary to successfully force reasoning bypass without stacking newlines (v18). |
-
----
-
-## Quick install
-
-Choose your environment and update the template:
-
-### LM Studio
-1. Open your Qwen model in the right-side panel.
-2. Scroll down to **Prompt Template**.
-3. Replace the template with the contents of `chat_template.jinja`.
-4. Click **Save**.
-
-### llama.cpp / koboldcpp
-```bash
---jinja --chat-template-file chat_template.jinja
-```
-
-### vLLM
-Replace the `"chat_template"` string in your `tokenizer_config.json` with the raw file contents. Use the `qwen3_coder` tool parser:
-```bash
---tool-call-parser qwen3_coder
-```
-
-### oMLX
-Overwrite `chat_template.jinja` in your local model directory. Load with `--jinja`. Remove any `chat_template_kwargs` overrides because the template handles everything internally.
-
----
-
-## Which file do I use?
-
-Both Qwen 3.5 and Qwen 3.6 variants (including 35B, 32B, 27B, and 14B parameters) have been consolidated. You only need the single `chat_template.jinja` file at the root of the repository.
-
-One-line versions (`chat_template_oneline.txt`) are pre-minified for engines that require a single-line template string.
-
----
-
-## The thinking toggle
-You can control the model reasoning behavior. Insert `<|think_on|>` or `<|think_off|>` anywhere in your system or user prompt.
-
-The template natively intercepts the tag, removes it from the final context so the model never sees it, and flips the reasoning mode instantly.
-
-**Fast answer, no reasoning:**
-```text
-System: You are a coding assistant. <|think_off|>
-User: What's 2+2?
-```
-
-**Deep reasoning:**
-```text
-System: You are a coding assistant. <|think_on|>
-User: Implement a red-black tree in Rust.
-```
-*(The tag syntax uses Qwen's control-token delimiters to guarantee it will never collide with legitimate text or file paths, unlike earlier community templates that used `/think`)*
-
----
-
-## Token Saving: Stripping past thoughts
-
-By default in v19, this template **preserves** all past `<think>` blocks in the chat history. This is intentional: it prevents the model from suffering "amnesia stalls" during complex, multi-step agentic loops, and it mathematically guarantees a 100% Prefix KV Cache hit rate on local inference engines.
-
-However, if you are running constrained hardware and need to save context tokens, you can explicitly disable this feature in your engine's template kwargs to automatically strip past thoughts:
-
-```json
-{
-  "preserve_thinking": false
-}
-```
-*(Note: Setting this to false will naturally reduce your KV Cache hit rate during multi-turn chats, as the prompt string will dynamically mutate).*
-
----
-
-<details>
-<summary>Technical Details of the Critical Fixes</summary>
-
-### 1. The "Empty Think" Poisoning & Logic Trap Cure (v19)
-Previous versions attempted to save tokens by replacing past thoughts with empty `<think>\n</think>` blocks, combined with an absolute system prompt demanding a tool be called immediately after `</think>`. This created a toxic in-context learning pattern: the model associated empty thoughts with tools, and full thoughts with forbidden conversational text, causing an 80%+ premature `<|im_end|>` stalling rate. v19 abolishes empty think injection and rewrites the `<IMPORTANT>` directives to explicitly authorize conversational synthesis after a thought block.
-
-### 2. KV Cache Safety & Autoregressive Normalization (v18/v19)
-Llama.cpp and vLLM utilize prefix KV caching to speed up generation. Because v19 now preserves historical thoughts chronologically by default, the rendered history perfectly synchronizes with the cached generated tokens. Combined with strict single `\n` normalization at autoregressive boundaries, this achieves a 100% KV Cache hit rate in multi-turn loops.
-
-### 3. Native XML Tool Call Format (v16)
-The model was trained with the XML-based tool call format used by Qwen3-Coder:
-```xml
-<tool_call>
-<function=tool_name>
-<parameter=param_name>
-value
-</parameter>
-</function>
-</tool_call>
-```
-v16 restored this format natively, making it compatible with all parsers while bypassing the `|items` crash by using C++ safe key iteration (`for args_name in tool_call.arguments`).
-
-### 4. Two-Tier Agentic Error Escalation (v15)
-When a tool call fails validation repeatedly, the model can enter a degenerate reasoning spiral. This template leverages a two-tier escalation system driven by a forward-tracked `consecutive_failures` counter:
-- **Tier 1 (1st error):** Generation prompt prefix changes to seed reasoning at a different token position, breaking the cached attractor state.
-- **Tier 2 (2nd+ consecutive errors):** Think block bypassed entirely. An urgent out-of-band directive forces an immediate corrected action wrapped safely within the user `tool_response` block.
-
-### 5. Smart False-Positive Detection (v18)
-Instead of broad substring matching that triggers false retry-loops on successful database returns containing words like "error", v18 utilizes strict structural guards looking for `Exception:`, `"error":`, `Traceback`, and `command not found`, combined with length gates and shell-echo exclusions (`$ `).
-
-### 6. minijinja Compatibility Constraints (v18/v20)
-Python-only Jinja2 features crash or misbehave on `minijinja`/`minja` (the C++ runtime used by llama.cpp, LM Studio, and MLX). All instances have been refactored for universal support:
-- `content | replace('<|think_on|>', '')` -> `content.split('<|think_on|>') | join('')` (Fixes a severe bug where `minja` silently drops the entire text payload if the replaced string is found at index 0).
-- `\| items` -> `for key in mapping`
-- `loop.previtem` -> `messages[loop.index0 - 1]`
-- `map('string')` -> `join('|')`
-- `\| first` -> `'$ ' in content`
-
-</details>
-
-<details>
-<summary>Comparison Matrix: Official vs Fixed vs Community</summary>
-
-| Feature | Official Qwen Templates | LuffyTheFox | mod-ellary | Pneuny | **This Fixed Template (v19)** |
-|---------|----------|-------------|------------|--------|----------------|
-| Tool call format | XML (native) | JSON | JSON | JSON | **XML (native, qwen3_coder compatible)** |
-| Tool arguments | Fails (`\|items`) | Fixed | Missing | Fixed | **Fixed (C++ safe XML)** |
-| Premature Stalls (Stopping Bug) | Stalls | Stalls | Stalls | Stalls | **Fixed via Logic Trap / Poisoning removal (v19)** |
-| Agentic Retry Stall & Reasoning Spiral | Stalls | Stalls | Stalls | Stalls | **Two-tier escalation system** |
-| False-positive tool errors | N/A | N/A | N/A | N/A | **Guarded (Strict structural matching)** |
-| Post-Tool Overthinking | Spams/Stalls | Broken | Broken | Broken | **Universal Synthesis** |
-| `--reasoning off` on tool errors | N/A | N/A | N/A | N/A | **Fully respected** |
-| `developer` role | Missing | Missing | Missing | Missing | **Added** |
-| Thinking toggle | None | None | `/think` (system only) | None | **`<\|think_off\|>` anywhere** |
-| Empty think in history | Spams empty blocks | Broken | Tags omitted | Broken | **Abolished completely (v19)** |
-| KV prefix caching | Breaks on dynamic history | Breaks | Breaks | Breaks | **100% stable out-of-the-box (v19)** |
-| Mid-conversation system | Crashes | Crashes | Crashes | Crashes | **Fixed** |
-| No-user-query crash | Crashes | Crashes | Crashes | Crashes | **Graceful fallback** |
-| Legacy AST support | Fails (`previtem`) | Fails | Fails | Fails | **Fixed (`index0`)** |
-| `</thinking>` hallucination | Fails | N/A | N/A | N/A | **Detected and safely trimmed** |
-
-</details>
-
----
-
-## Running the test suite
-
-```bash
-python3 scripts/test_v20.py
-```
-
-Tests cover: `auto_disable_thinking_with_tools`, payload truncation logic, parallel tool spacing, mid-conversation system rendering, deep agent loop fallback, XML tool format, `<|think_off|>` / `<|think_on|>` inline overrides, and all legacy v19 regression tests.
-
----
-
-## Authorship
-
-| Role | Author |
-|------|--------|
-| Original models | Alibaba Cloud (Qwen team) |
-| Template fixes | [froggeric](https://huggingface.co/froggeric) |
-| C++ AST optimizations | [barubary](https://github.com/spiritbuun/buun-llama-cpp) / `spiritbuun` |
-
-## License
-
-Apache-2.0, inherited from Qwen.

archive/README-v21.md

@@ -1,234 +0,0 @@
----
-license: apache-2.0
-tags:
-  - jinja
-  - chat-template
-  - qwen
-  - qwen3.5
-  - qwen3.6
-  - lm-studio
-  - mlx
-  - llama.cpp
-  - vllm
-  - tool-calling
-  - thinking
----
-
-# Fixed jinja chat templates for Qwen 3.5 & 3.6 (v21)
-
-This is a drop-in Jinja template that fixes rendering errors, KV cache invalidation, token waste, and fatal agentic stalling in the official Qwen chat templates. 
-
-It works across LM Studio, llama.cpp, vLLM, MLX, oMLX, and any engine that supports HuggingFace Jinja templates. You only need the single `chat_template.jinja` file at the root of the repository for all Qwen 3.5 and 3.6 variants.
-
----
-
-<details>
-<summary><b>Quick Install</b></summary>
-
-Choose your environment and update the template:
-
-### LM Studio
-1. Open your Qwen model in the right side panel.
-2. Scroll down to **Prompt Template**.
-3. Replace the template with the contents of `chat_template.jinja`.
-4. Click **Save**.
-
-### llama.cpp / koboldcpp
-Use the file directly in your launch command:
-```bash
---jinja --chat-template-file chat_template.jinja
-```
-
-### vLLM
-Replace the `"chat_template"` string in your `tokenizer_config.json` with the raw file contents. Use the `qwen3_coder` tool parser:
-```bash
---tool-call-parser qwen3_coder
-```
-
-### oMLX
-Overwrite `chat_template.jinja` in your local model directory. Load with `--jinja`. Remove any `chat_template_kwargs` overrides because the template handles everything internally.
-
-</details>
-
----
-
-## Why you need this
-
-The official Qwen templates contain restrictions and Python-specific Jinja logic that break usage on many inference engines and agent frameworks.
-
-<details open>
-<summary><b>Critical Issues Fixed</b></summary>
-
-| Area | Issue | The Fix |
-|---|---|---|
-| **Agentic Loop** | Model aborts turn when combining chat and a tool call. | Cured "Empty Think" poisoning. |
-| **Agentic Loop** | Model gets stuck emitting the identical failing tool call. | Added two-tier error escalation to force correction. |
-| **Agentic Loop** | Model panics and debates internal rules after fetching data. | Broadened `<think>` instructions to allow synthesis. |
-| **Agentic Loop** | API returns containing the word "error" trigger false loops. | Replaced broad matching with strict structural guards. |
-| **Performance** | Mutated past turns constantly destroy the prefix cache. | Enforced chronological history for a 100% KV Cache hit rate. |
-| **Performance** | Deep Jinja nesting drops `llama.cpp` speed by 80%. | Flattened the AST architecture to maximize throughput. |
-| **Compatibility** | Python-specific filters crash C++ inference engines. | Rewrote all filters to be 100% `minijinja` safe. |
-| **Compatibility** | Qwen-native parsers (like vLLM) crash on JSON formatting. | Maintained canonical Qwen XML format as the default. |
-| **Compatibility** | Older API setups and wrappers crash on native XML. | Added a `tool_call_format="json"` opt-in override. |
-| **Compatibility** | Anthropic `message.thinking` payloads are rejected. | Added native Anthropic reasoning support. |
-| **Stability** | Massive tool data returns blow out the context window. | Added dynamic payload truncation limits. |
-| **Stability** | Mid-conversation system prompts crash the template. | Added native support for arbitrary system messages. |
-| **Stability** | Model calls a tool without closing its reasoning tags. | Auto-injects closing tags before tool boundaries. |
-| **Edge Cases** | Text occasionally duplicates during streaming generation. | Restored canonical spacing to the generation prompt. |
-| **Edge Cases** | Model hallucinates reasoning tags when thinking is disabled. | Injected strict boundaries to force reasoning bypass. |
-
-</details>
-
-
-
----
-
-## Customization & Usage
-
-<details>
-<summary><b>The Thinking Toggle</b></summary>
-
-You can control the model reasoning behavior. Insert `<|think_on|>` or `<|think_off|>` anywhere in your system or user prompt. The template intercepts the tag, removes it from the final context so the model never sees it, and flips the reasoning mode instantly.
-
-**Fast answer, no reasoning:**
-```text
-System: You are a coding assistant. <|think_off|>
-User: What's 2+2?
-```
-
-**Deep reasoning:**
-```text
-System: You are a coding assistant. <|think_on|>
-User: Implement a red-black tree in Rust.
-```
-*(The tag syntax uses Qwen's control token delimiters to guarantee it will never collide with legitimate text or file paths, unlike earlier community templates that used `/think`)*
-
-</details>
-
-<details>
-<summary><b>Token Saving (Stripping past thoughts)</b></summary>
-
-By default, this template **preserves** all past `<think>` blocks in the chat history. This prevents the model from suffering "amnesia stalls" during complex agentic loops, and it mathematically guarantees a 100% Prefix KV Cache hit rate on local inference engines.
-
-If you are running constrained hardware and need to save context tokens, you can explicitly disable this feature in your engine's template kwargs to automatically strip past thoughts:
-```json
-{
-  "preserve_thinking": false
-}
-```
-*(Note: Setting this to false will reduce your KV Cache hit rate during multi-turn chats because the prompt string will dynamically mutate).*
-
-</details>
-
-<details>
-<summary><b>Tool Call Format Override (JSON vs XML)</b></summary>
-
-Qwen models are natively trained to output tool calls in XML (`<function=name>`). By default, this template uses this native XML format to maximize the model's intelligence and reliability. 
-
-**For most users (including those using `vLLM` or `llama.cpp` / `llama-server`), you do NOT need to change anything.** Modern inference engines natively understand Qwen's XML and will automatically translate it into standard OpenAI API responses for your downstream clients.
-
-**When to use the JSON override:**
-If you are using a custom wrapper, an older engine version, or a specific framework (like `ik_llama`) that *strictly* expects the model itself to output Hermes JSON (`{"name": "...", "arguments": {...}}`) and crashes on XML, you can force the template to use JSON by passing this kwarg:
-```json
-{
-  "tool_call_format": "json"
-}
-```
-> [!WARNING]
-> When you opt into the JSON format, the template explicitly disables the `max_tool_arg_chars` truncation feature. Truncating a JSON string structurally corrupts its syntax, which would poison the model's history and crash downstream parsers.
-
-</details>
-
----
-
-<details>
-<summary><b>Running the test suite</b></summary>
-
-```bash
-python3 scripts/test_v21.py
-```
-Tests cover `auto_disable_thinking_with_tools`, payload truncation logic, parallel tool spacing, mid-conversation system rendering, deep agent loop fallback, XML tool format, `<|think_off|>` / `<|think_on|>` inline overrides, and all legacy regression tests.
-
-</details>
-
----
-
-## Authorship
-| Role | Author |
-|------|--------|
-| Original models | Alibaba Cloud (Qwen team) |
-| Template fixes | [froggeric](https://huggingface.co/froggeric) |
-| C++ AST optimizations | [barubary](https://github.com/spiritbuun/buun-llama-cpp) / `spiritbuun` |
-
-## License
-Apache-2.0, inherited from Qwen.
-
----
-
-<details>
-<summary>Technical Details of the Critical Fixes</summary>
-
-### 1. The "Empty Think" Poisoning & Logic Trap Cure
-Previous versions attempted to save tokens by replacing past thoughts with empty `<think>\n</think>` blocks, combined with an absolute system prompt demanding a tool be called immediately after `</think>`. This created a toxic learning pattern: the model associated empty thoughts with tools, and full thoughts with forbidden conversational text, causing an 80%+ premature `<|im_end|>` stalling rate. We abolished empty think injection and rewrote the `<IMPORTANT>` directives to explicitly authorize conversational synthesis after a thought block.
-
-### 2. KV Cache Safety & Autoregressive Normalization
-Llama.cpp and vLLM utilize prefix KV caching to speed up generation. Because this template now preserves historical thoughts chronologically by default, the rendered history perfectly synchronizes with the cached generated tokens. Combined with strict single `\n` normalization at autoregressive boundaries, this achieves a 100% KV Cache hit rate in multi-turn loops.
-
-### 3. Native XML Tool Call Format
-The model was trained with the XML tool call format used by Qwen3-Coder. We restored this format natively, making it compatible with all parsers while bypassing the `|items` crash by using C++ safe key iteration (`for args_name in tool_call.arguments`).
-
-### 4. Two-Tier Agentic Error Escalation
-When a tool call fails validation repeatedly, the model can enter a degenerate reasoning spiral. This template leverages a two-tier escalation system driven by a forward tracked `consecutive_failures` counter. On the first error, the generation prompt prefix changes to seed reasoning at a different token position, breaking the cached attractor state. On the second consecutive error, the think block is bypassed entirely and an urgent out-of-band directive forces an immediate corrected action wrapped safely within the user `tool_response` block.
-
-### 5. Smart False-Positive Detection
-Instead of broad substring matching that triggers false retry loops on successful database returns containing words like "error", this template utilizes strict structural guards looking for `Exception:`, `"error":`, `Traceback`, and `command not found`, combined with length gates and shell echo exclusions (`$ `).
-
-### 6. minijinja Compatibility Constraints
-Python-only Jinja2 features crash or misbehave on `minijinja` (the C++ runtime used by llama.cpp, LM Studio, and MLX). All instances have been refactored for universal support:
-* `content | replace('<|think_on|>', '')` became `content.split('<|think_on|>') | join('')` (Fixes a bug where `minja` silently drops the entire text payload if the replaced string is found at index 0).
-* `\| items` became `for key in mapping`
-* `loop.previtem` became `messages[loop.index0 - 1]`
-* `map('string')` became `join('|')`
-* `\| first` became `'$ ' in content`
-
-### 7. AST Flattening for C++ Throughput
-Deeply nested Jinja loops and macros create severe parsing bottlenecks in C++ inference engines. We flattened the AST architecture, effectively curing an 80% inference throughput drop on `llama.cpp` by streamlining how `ns_state` tracking and historical rendering loops are evaluated.
-
-### 8. Dynamic Payload Truncation
-Massive API or database returns can instantly blow out a model's context window. We implemented `max_tool_arg_chars` and `max_tool_response_chars` limiters that safely slice oversized payloads. Crucially, this truncation is automatically disabled when the `tool_call_format="json"` override is active, as slicing a serialized JSON string structurally corrupts the data and crashes downstream parsers.
-
-### 9. Reasoning Bypass Hallucination Mitigation
-When thinking is disabled, Qwen models often hallucinate reasoning tags due to their training bias. We injected a safe boundary and adjusted the `<IMPORTANT>` system block to remove explicit mentions of `</think>` during tool instructions. This successfully stops the model from hallucinating closing tags when attempting to call tools in a no-reasoning state.
-
-</details>
-
-<details>
-<summary>Update History & Changelog</summary>
-
-> **2026-07-02 Update (v21.3): Optional JSON Tool Format Kwarg.** Added an optional `tool_call_format="json"` override for the `chat_template_kwargs`. This provides an escape hatch for users on specific setups (like custom wrappers or older engines that only support Hermes JSON parsing) without breaking the canonical XML default or degrading the model's primary training distribution. `max_tool_arg_chars` truncation is safely bypassed in JSON mode to prevent syntax corruption.
-
-> **2026-07-02 Update (v21.2): Reasoning Bypass Hallucination Fix.** Adjusted the `<IMPORTANT>` block instructions to remove explicit mentions of `</think>` when defining tool call behavior. This stops the model from hallucinating `</think>` tags as a prefix when reasoning is explicitly disabled.
-
-> **2026-07-02 Update (v21.1): Reliability Overhaul & XML Revert.** Addressed critical bugs and compatibility issues, particularly around prefix cache efficiency. (1) **Tool Call XML Format Revert:** Reverted PR 45 to restore the native XML format, as JSON fundamentally broke `vLLM`'s native `qwen3_coder` parser. (2) **Prefix Cache Fixes:** Restored the `preserve_thinking` default to `true` and removed extraneous newlines that broke caching. (3) **Prompt Injection Guard:** `<|think_off|>` tags in untrusted tool responses are now correctly ignored. (4) **Quoted Tag Bug Fix:** The template no longer corrupts history when the assistant quotes `</think>`. (5) **Anthropic `message.thinking`:** Added support for Anthropic reasoning content. (6) **False-Positive Tool Errors:** Reduced error detection scope to the first 80 characters of a response to prevent false positives. (7) **Canonical Generation Prompt:** Restored the canonical `\n\n` spacing to the non-thinking generation prompt to fix answer duplication issues under streaming. *(Huge thanks to `Moore2877`, `choongng`, and the community for their excellent contributions!)*
-
-> **2026-06-05 Update (v20): The Architect Patch.** Major structural update for agentic loops and C++ inference engines. (1) **Minja AST Flattening:** Optimized Jinja nesting to fix parsing bottlenecks that dropped inference throughput by 80% on `llama.cpp`. (2) **Minja Replace Bug Fix (Hotfix):** Bypassed a C++ parsing bug in `llama.cpp` where using the `replace` filter at index 0 of a user prompt silently dropped the entire text payload. Inline thinking toggles now use `split` and `join` for robust stripping. (3) **Auto-disable Thinking:** Introduced `auto_disable_thinking_with_tools` kwarg (default `false`) that allows users to instantly shut off reasoning blocks during tool use. (4) **Deep Agent Fallbacks:** Resolved exceptions triggered by mid-conversation system prompts or loops lacking human `user` messages. (5) **Payload Truncation:** Implemented `max_tool_arg_chars` and `max_tool_response_chars` configurations to definitively stop context window explosions from massive data returns. *(Huge thanks to `barubary` / `spiritbuun` for their contributions to these C++ architecture optimizations!)*
-
-> **2026-05-18 Update (v19): The Agentic Loop Cure.** (1) **Abolished "Empty Think" Poisoning:** Rewrote the AST history rendering to completely remove the injection of empty `<think>\n</think>` blocks. This cures a severe in-context learning bias where the model assumed tools could only be called if it didn't think first, which was causing 80%+ of premature `<|im_end|>` turn aborts. (2) **System Prompt Logic Trap Removed:** Softened the absolute tool mandate in the `<IMPORTANT>` block and restored Universal Synthesis instructions. The model is now explicitly permitted to transition from `</think>` to a conversational answer without panicking. (3) **True 100% KV Cache & Amnesia Fix:** `preserve_thinking` now defaults to `true`. Past thoughts are retained chronologically, permanently curing "amnesia stalls" during multi-step tool loops while mathematically guaranteeing 100% KV Cache prefix matching out of the box.
-
-> **2026-05-16 Update (v18): Stability & Precision Patch.** (1) **Bulletproof False-Positive Detection:** Shifted agentic error detection from broad substring matching to strict structural formats (e.g. `"error":`, `Exception:`, `Traceback`), completely curing false-positive retry loops when successful JSON returns simply contain the word "error" or "fail". (2) **Legacy Engine Compatibility:** Replaced `loop.previtem` with explicit array indexing, fixing AST crashes on older `llama.cpp` and `minijinja` builds that do not track loop state items. (3) **True Whitespace Normalization:** Fixed a bug where reasoning bypasses and hallucinated tag recovery stacked hidden multi-newlines (`\n\n\n`), strictly fulfilling the 100% KV Cache hit rate claim for all edge cases. (4) **Code Cleanup:** Removed dead conditional branches during XML tool parsing.
-
-> **2026-05-15 Update (v17):** (1) **Unified Template:** Consolidated Qwen 3.5 and Qwen 3.6 into a single `chat_template.jinja` file that handles all variants. (2) **Fixed "Mutually Exclusive" Stopping Bug:** Changed the history pruning logic from wiping the entire turn to safely array slicing out just the raw tool tags (`content.split('<tool_call>')[0]`). This preserves the conversational text in the history, which cures the bug where the model would artificially abort its turn (output `<|im_end|>`) when it wanted to talk and use a tool simultaneously. (3) **100% KV Cache Hit Rate Restoration:** Fully normalized internal whitespace logic (`\n\n` -> `\n`) around think blocks and tool calls to exactly match the model's native autoregressive generation spacing. This perfectly synchronizes the template's rendered history with the cached generated tokens, completely eliminating the severe cache invalidation and full prompt re-processing issues present in v16.
-
-> **2026-05-14 Update (v16):** (1) **Native XML tool format:** reverted from JSON back to the native `<function=name>` / `<parameter=x>` format the model was trained on, restoring full compatibility with vLLM's `qwen3_coder` parser and all inference engines that implement the Qwen tool protocol. (2) **`--reasoning off` respected in error paths:** when thinking is disabled (`enable_thinking=false` / `--reasoning off`), the error escalation directives are now injected as plain text without opening any `<think>` block, preventing degenerate prompts in no-reasoning sessions. (3) **Smarter false-positive detection:** short shell command results (starting with `$ `) and search results with timing footers (`Took X.Xs`) are now correctly excluded from error detection, preventing tool retry loops when commands succeed but their output happens to contain the word `error`. (4) **`consecutive_failures` counter no longer resets on assistant messages**, allowing Tier 2 escalation to actually fire across multi-turn tool retry chains.
-
-> **2026-05-13 Update (v15):** (1) **Two-tier error escalation:** replaced the brittle backwards lookahead error detection with a fully forward tracking `last_tool_failed` + `consecutive_failures` counter. On the first error the generation prompt is pre-seeded with a correction directive inside `<think>`; on the 2nd+ consecutive error the think block is bypassed and an out-of-band directive forces an immediate corrected action. (2) **Length-gated detection:** error signals are only read from short tool responses (< 500 chars), preventing false positives when reading code files containing `error`, `exception`, etc in legitimate content. (3) **Static system prompt:** tool instructions are now fully unconditional, permanently eliminating the KV cache invalidation vector introduced in v14.
-
-> **2026-05-12 Update (v14):** Cured tool amnesia loops and post-tool overthinking friction! Implemented Smart Loop Preservation to dynamically scan subsequent tool returns for error markers and conditionally preserve historical reasoning context during active tool failures. Broadened the system instruction scope to define `<think>` as a dual-purpose planning or synthesis space, completely eliminating indecisiveness post-tool retrieval.
-
-> **2026-05-11 Update (v13):** Reverted tool schemas and assistant output formatting to standard JSON to natively fix downstream MCP parser crashes and C++ implicit enum coercion bugs. Removed the `ns_scan` history loop to permanently fix KV cache invalidation mid-conversation. Replaced global string replacement for hallucinated tags with a C++ safe, localized array slicing method to prevent data corruption on user code blocks.
-
-> **2026-05-10 Update (v12):** Fixed agent stalls, parameter data loss, and hallucination bugs! Restored dynamic tool instructions and the `<IMPORTANT>` formatting reminder block to stop grammar parser crashes.
-
-> **2026-05-10 Update (v11):** Fixed agent looping and overthinking! Re-implemented `preserve_thinking` kwarg to properly strip reasoning blocks from history by default, and restored the reasoning bypass (`<think>\n\n</think>\n\n`).
-
-</details>

archive/README-v22.1.md

@@ -1,285 +0,0 @@
----
-license: apache-2.0
-tags:
-  - jinja
-  - chat-template
-  - qwen
-  - qwen3.5
-  - qwen3.6
-  - qwen3.8
-  - lm-studio
-  - mlx
-  - llama.cpp
-  - vllm
-  - tool-calling
-  - thinking
----
-
-# Fixed jinja chat templates for Qwen 3.5, 3.6 & 3.8 (v22.1)
-
-This is a universal drop-in Jinja template that fixes rendering errors, KV cache invalidation, token waste, empty think poisoning, and fatal agentic stalling across official Qwen chat templates.
-
-It works across LM Studio, llama.cpp, vLLM, MLX, oMLX, KoboldCPP, and any engine that supports Hugging Face Jinja templates. You only need the single `chat_template.jinja` file at the root of this repository for all Qwen 3.5, 3.6, and 3.8 model sizes.
-
----
-
-## What is new: The Qwen 3.8 Update
-
-Qwen has released their 3.8 generation starting with `Qwen3.8-2.4T-A95B` and `Qwen3.8-27B`. While the official 3.8 template adopted our default reasoning preservation, it also introduced severe regressions and rigid lockdowns that break local setups. This release brings full Qwen 3.8 support while fixing these official bugs:
-
-1. **Prompt-Steered Reasoning Effort:** Qwen 3.8 introduces 3 core reasoning levels (`xhigh`, `medium`, `low`). The template injects official steering instructions when requested, and auto-suppresses them when thinking is turned off. Client API aliases (`high` / `max` for `xhigh`, `minimal` for `low`, and `none` for thinking off) are supported automatically for OpenAI and vLLM client compatibility.
-2. **Safe Default Reasoning Baseline (`medium`):** In official Qwen 3.8, `reasoning_effort` defaulted to `xhigh`. On complex tasks with finite token limits, this pushed the model to explore alternate branches until hitting `max_tokens`, returning zero content. We set the default to `medium` (zero injected tokens), preserving 100% prefix cache parity with v21.3 while eliminating empty-content failures.
-3. **Inline Chat Tags for Direct Effort Steering:** You can steer thinking depth directly inside chat prompts (for LM Studio, OpenCode, or WebUI) using inline tags:
-   * `<|think_low|>`: Enables thinking with concise reasoning instructions.
-   * `<|think_medium|>`: Enables thinking with standard baseline instructions.
-   * `<|think_xhigh|>`: Enables thinking with deep reasoning instructions.
-   * `<|think_off|>`: Turns off reasoning completely for fast responses.
-   *(All tags are automatically stripped from the rendered prompt, so the model never sees raw control tags)*.
-4. **Restored Fast Mode (No Reasoning):** Official 3.8 throws a fatal runtime exception if you pass `enable_thinking=false`. We removed this lockdown, giving you complete freedom to disable reasoning via kwargs or inline `<|think_off|>` tags.
-5. **Cured Official 3.8 Empty Think Bug:** Official 3.8 removed the in-content thinking parser. In multi-turn chats where reasoning is stored inside message content, official 3.8 injects a blank `<think></think>` block before the real thoughts. This template extracts reasoning cleanly without duplicating tags.
-6. **Universal Tool Arguments:** Official 3.8 crashes with `TypeError: Can only get item pairs from a mapping` when clients send standard OpenAI string arguments. This template handles both Python dictionaries and JSON strings seamlessly.
-7. **Native llama.cpp `--reasoning-preserve` Support:** Added native support for the new `llama.cpp` CLI flag via the `preserve_reasoning` alias.
-8. **Diagnostic Tooling:** Added `scripts/check_applied.py` to check whether `chat_template.jinja` or `tokenizer_config.json` is actively loaded by your runtime.
-
----
-
-<details open>
-<summary><b>Quick Install & Engine Setup</b></summary>
-
-### llama.cpp / llama-server / koboldcpp
-Run `llama-server` with the template file and DeepSeek reasoning format:
-```bash
-llama-server -m your_model.gguf --jinja --chat-template-file chat_template.jinja --reasoning-format deepseek
-```
-*Why `--reasoning-format deepseek` matters:* When connecting coding agents like OpenCode, Claude Code, or Pi.dev to `llama-server`, this flag extracts `<think>` blocks into the dedicated `reasoning_content` API response field. This prevents raw thinking tokens from leaking into the text stream and stopping tool calls midway.
-
-*Native CLI flag:* On recent `llama.cpp` builds, you can pass `--reasoning-preserve` directly to ensure 100% Prefix KV Cache retention.
-
-### LM Studio
-1. Open your Qwen model in the right side panel.
-2. Scroll down to **Prompt Template**.
-3. Replace the template with the contents of `chat_template.jinja`.
-4. Click **Save**.
-
-### vLLM
-Replace the `"chat_template"` string in your `tokenizer_config.json` with `chat_template_oneline.txt` (or raw `chat_template.jinja`).
-```bash
-vllm serve Qwen/Qwen3.8-2.4T-A95B --tool-call-parser qwen3_xml
-```
-*Parser selection:* Use `--tool-call-parser qwen3_xml` on current vLLM releases. If you are on an older vLLM build, use `--tool-call-parser qwen3_coder`. If you explicitly set `tool_call_format="json"`, use `--tool-call-parser hermes`.
-
-### oMLX / MLX
-Overwrite `chat_template.jinja` in your local model directory and launch with `--jinja`.
-
-</details>
-
----
-
-## Why you need this
-
-The official Qwen templates contain engine restrictions, Python-specific Jinja logic, and regressions that break local inference and agent workflows.
-
-<details open>
-<summary><b>Critical Issues Fixed</b></summary>
-
-| Area | Issue in Official Templates | The Fix |
-|---|---|---|
-| **Qwen 3.8 Support** | Official 3.8 crashes if `enable_thinking=false`. | **Restored Fast Mode**. Supports fast non-reasoning mode via kwargs or `<\|think_off\|>`. |
-| **Qwen 3.8 Token Safety** | Official `xhigh` default burns token budgets with zero content returned. | **Safe `medium` Default**. Zero prompt injection unless explicitly requested. |
-| **Qwen 3.8 Regression** | Official 3.8 injects duplicate blank `<think></think>` in chat history. | **Cured Empty Think Poisoning**. Robust multi-format reasoning extraction. |
-| **Reasoning Control** | Inability to change reasoning effort in chat interfaces. | **Inline Chat Tags**. Full support for `<\|think_low\|>`, `<\|think_medium\|>`, and `<\|think_xhigh\|>`. |
-| **Compatibility** | `llama.cpp --reasoning-preserve` CLI flag compatibility. | **Native Alias Support**. Supports both `preserve_reasoning` and `preserve_thinking`. |
-| **Compatibility** | JSON-string tool arguments (OpenAI / Ollama) crash official templates. | **Universal Tool Parsing**. Safely handles mappings, JSON strings, and scalar args. |
-| **Agentic Loop** | Model aborts turn when combining conversational text and a tool call. | Cured "Empty Think" poisoning and softened imperative system directives. |
-| **Agentic Loop** | Model gets stuck emitting the identical failing tool call. | Added two-tier error escalation to force correction while retaining reasoning. |
-| **Agentic Loop** | Model panics and debates internal rules after fetching data. | Broadened `<think>` instructions to authorize conversational synthesis. |
-| **Agentic Loop** | API returns containing the word "error" trigger false retry loops. | Replaced broad matching with strict structural guards. |
-| **Performance** | Mutated past turns destroy the prefix cache. | Enforced chronological history for a 100% KV Cache hit rate. |
-| **Performance** | Deep Jinja nesting drops `llama.cpp` speed by 80%. | Flattened the AST architecture to maximize throughput. |
-| **Compatibility** | Python-specific filters crash C++ inference engines. | Rewrote all filters to be 100% `minijinja` safe. |
-| **Compatibility** | Qwen-native parsers (like vLLM) crash on JSON formatting. | Maintained canonical Qwen XML format as the default. |
-| **Compatibility** | Older API setups and wrappers crash on native XML. | Added a `tool_call_format="json"` opt-in override. |
-| **Compatibility** | Anthropic `message.thinking` payloads are rejected. | Added native Anthropic reasoning support. |
-| **Stability** | Massive tool data returns blow out the context window. | Added dynamic payload truncation limits. |
-| **Stability** | Mid-conversation system prompts crash the template. | Added native support for arbitrary system and developer messages. |
-| **Edge Cases** | Text duplicates during streaming generation. | Restored canonical spacing to the generation prompt. |
-| **Edge Cases** | Model hallucinates reasoning tags when thinking is disabled. | Injected strict boundaries to force clean reasoning bypass. |
-
-</details>
-
----
-
-## Customization & Kwarg Reference
-
-<details open>
-<summary><b>1. Reasoning Effort Steering (Qwen 3.8)</b></summary>
-
-Qwen 3.8 has 3 native prompt-steered reasoning levels. You can control this via template kwargs or directly inline in your chat messages:
-
-**Via Template Kwargs (`chat_template_kwargs`):**
-```json
-{
-  "reasoning_effort": "xhigh"
-}
-```
-* **`"medium"` (Default / Safe Baseline):** No extra instruction text injected. Preserves 100% Prefix KV Cache parity with v21 and lets the model reason naturally without token-budget traps.
-* **`"xhigh"` (Deep Reasoning):** Injects Qwen's official deep reasoning instruction:
-  > *"Reasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer."*
-* **`"low"` (Concise Reasoning):** Injects concise thinking instructions for fast, summary-oriented reasoning:
-  > *"Reasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration."*
-
-*API Compatibility Aliases:*
-To prevent errors when calling the model through standard API proxies:
-* `"high"` and `"max"` automatically map to `"xhigh"` (standard OpenAI API clients send `"high"`).
-* `"minimal"` automatically maps to `"low"`.
-* `"none"` disables thinking entirely.
-
-**Via Inline Chat Tags (Per-Prompt Steering):**
-* `Solve this proof <|think_xhigh|>` (Deep reasoning)
-* `Explain recursion briefly <|think_low|>` (Concise reasoning)
-* `What is the capital of France? <|think_off|>` (No reasoning / fast mode)
-
-*(Note: When thinking is disabled, reasoning effort instructions are automatically suppressed).*
-
-</details>
-
-<details>
-<summary><b>2. KV Cache Preservation (`preserve_reasoning` & `preserve_thinking`)</b></summary>
-
-By default, this template **preserves** all past `<think>` blocks in the chat history. This prevents the model from suffering "amnesia stalls" during complex agentic loops and guarantees a 100% Prefix KV Cache hit rate on local inference engines.
-
-* On recent `llama.cpp` builds, pass `--reasoning-preserve` directly.
-* Or pass via template kwargs:
-```json
-{
-  "preserve_thinking": true
-}
-```
-
-If you are on severely memory-constrained hardware and need to save context tokens, set `"preserve_thinking": false` (or `"preserve_reasoning": false`) to strip past thoughts.
-
-</details>
-
-<details>
-<summary><b>3. Tool Call Format Override (JSON vs XML)</b></summary>
-
-Qwen models are natively trained to output tool calls in XML (`<function=name>`). By default, this template uses native XML to maximize reliability.
-
-**When to use the JSON override:**
-If you are using a framework or harness (such as specific Hermes Agent configurations) that strictly requires Hermes JSON (`{"name": "...", "arguments": {...}}`), pass:
-```json
-{
-  "tool_call_format": "json"
-}
-```
-*(When opting into JSON format, argument truncation is safely bypassed to avoid corrupting JSON syntax)*.
-
-</details>
-
-<details>
-<summary><b>4. Dynamic Payload Truncation</b></summary>
-
-To prevent oversized tool returns from blowing out context limits:
-* `max_tool_arg_chars` (default `0` / disabled): Slices oversized tool call arguments.
-* `max_tool_response_chars` (default `0` / disabled): Slices oversized tool output data.
-
-</details>
-
----
-
-<details>
-<summary><b>Diagnostic Script & Test Suite</b></summary>
-
-### Check Active Template on Your Model
-Run the included diagnostic utility on your model folder or GGUF:
-```bash
-python3 scripts/check_applied.py /path/to/your/model
-```
-
-### Running the Test Suite
-```bash
-python3 scripts/test_v22.py
-```
-Tests cover 34 automated verification cells including `reasoning_effort` levels, monotonic API mappings, inline chat tags, multi-part payloads, tool call serialization, dynamic truncation, error escalation, and multi-turn history parsing.
-
-</details>
-
----
-
-## Authorship
-| Role | Author |
-|------|--------|
-| Original models | Alibaba Cloud (Qwen team) |
-| Template fixes | [froggeric](https://huggingface.co/froggeric) |
-| C++ AST optimizations | [barubary](https://github.com/spiritbuun/buun-llama-cpp) / `spiritbuun` |
-
-## License
-Apache-2.0, inherited from Qwen.
-
----
-
-<details>
-<summary>Technical Details of the Critical Fixes</summary>
-
-### 1. The "Empty Think" Poisoning and Logic Trap Cure
-Previous templates attempted to save tokens by replacing past thoughts with empty `<think>\n</think>` blocks, combined with an absolute system prompt demanding a tool be called immediately after `</think>`. This created a toxic pattern where the model associated empty thoughts with tools, causing an 80%+ premature turn abort rate. We abolished empty think injection and rewrote the `<IMPORTANT>` directives to explicitly authorize conversational synthesis after thinking. In this release, we also cured official Qwen 3.8's history bug where missing in-content parsers created duplicate blank think tags.
-
-### 2. Upfront Pre-Scan for Control Tags & Inline Effort Steering
-In Jinja templates, system prompts are assembled before iterating over message history. We introduce a comprehensive upfront pre-scan covering raw strings, string lists, and multi-part content lists (`[{'type': 'text', 'text': '...'}]`). This resolves `<|think_off|>`, `<|think_on|>`, `<|think_low|>`, `<|think_medium|>`, and `<|think_xhigh|>` states before the system message is built, ensuring reasoning instructions are never injected into non-reasoning turns and all tags are cleanly stripped during rendering.
-
-### 3. KV Cache Safety and Autoregressive Normalization
-Llama.cpp and vLLM utilize prefix KV caching to speed up generation. Because this template preserves historical thoughts chronologically by default and defaults `reasoning_effort` to `medium` (zero system tokens), rendered history perfectly synchronizes with cached generated tokens. Combined with strict single newline normalization at autoregressive boundaries, this achieves a 100% KV Cache hit rate in multi-turn sessions.
-
-### 4. Native XML Tool Format and Universal Serialization
-The model was trained with the XML tool format used by Qwen3-Coder. We restored this format natively while bypassing the `|items` crash by handling both mapping dictionaries and JSON strings. This eliminates crashes when standard OpenAI proxies pass stringified arguments.
-
-### 5. Two-Tier Agentic Error Escalation
-When a tool call fails validation repeatedly, the model can enter a degenerate reasoning spiral. This template leverages a two-tier escalation system driven by a forward-tracked `consecutive_failures` counter. On the first error, a diagnostic warning is injected. On the second consecutive error, an urgent system warning forces a fundamentally different approach while retaining the reasoning block so the model can plan its correction.
-
-### 6. Smart False-Positive Detection
-Instead of broad substring matching that triggers false retry loops on successful database returns containing words like "error", this template utilizes strict structural guards looking for `Exception:`, `"error":`, `Traceback`, and `command not found`, combined with length gates and shell echo exclusions (`$ `).
-
-### 7. minijinja Compatibility Constraints
-Python-only Jinja2 features crash or misbehave on `minijinja` (the C++ runtime used by llama.cpp, LM Studio, and MLX). All instances have been refactored for universal support:
-* `content | replace('<|think_on|>', '')` became `content.split('<|think_on|>') | join('')` (fixes a bug where `minja` silently drops the entire text payload if the replaced string is found at index 0).
-* `| items` became `for key in mapping`.
-* `loop.previtem` became explicit array indexing.
-* `map('string')` became `join('|')`.
-* `| first` became `'$ ' in content`.
-
-### 8. AST Flattening for C++ Throughput
-Deeply nested Jinja loops and macros create severe parsing bottlenecks in C++ inference engines. We flattened the AST architecture, effectively curing an 80% inference throughput drop on `llama.cpp` by streamlining how `ns_state` tracking and historical rendering loops are evaluated.
-
-### 9. Dynamic Payload Truncation
-Massive API or database returns can instantly blow out a model's context window. We implemented `max_tool_arg_chars` and `max_tool_response_chars` limiters that safely slice oversized payloads. Crucially, this truncation is automatically disabled when `tool_call_format="json"` is active, as slicing a serialized JSON string structurally corrupts the data and crashes downstream parsers.
-
-### 10. Reasoning Bypass Hallucination Mitigation
-When thinking is disabled, Qwen models often hallucinate reasoning tags due to their training bias. We injected a safe boundary and adjusted the `<IMPORTANT>` system block to remove explicit mentions of `</think>` during tool instructions. This stops the model from hallucinating closing tags when calling tools in a no-reasoning state.
-
-</details>
-
----
-
-<details>
-<summary>Update History & Changelog</summary>
-
-> **2026-08-16 Update (v22.1): The Qwen 3.8 Update (Bounded Reasoning Defaults, Inline Chat Tags, and Diagnostic Utility).**
-> 1. **Full Qwen 3.8 Support:** Single drop-in template covering all Qwen 3.5, 3.6, and 3.8 model variants (`Qwen3.8-2.4T-A95B`, `Qwen3.8-27B`).
-> 2. **Default `reasoning_effort` to `medium`:** Replaced the unsafe `xhigh` default with `medium` (zero injected tokens). Eliminates the runaway reasoning token-burn failure where models explore branches until hitting `max_tokens` with empty content (#72).
-> 3. **Inline Chat Tags:** Added support for `<|think_low|>`, `<|think_medium|>`, and `<|think_xhigh|>` tags directly inside chat messages (#70).
-> 4. **API Mapping & Aliasing:** Added case-insensitive alias support for client and serving runtimes (`high`/`max` -> `xhigh`, `minimal` -> `low`, `none` -> thinking off).
-> 5. **Sequential Control Tag Stripping:** Ensured all 7 control tags are cleanly stripped across system, user, and multi-part content without prompt leakage.
-> 6. **Cured Official 3.8 Empty Think Bug:** Fixed a regression in the official Qwen 3.8 template where removing `<think>` extraction caused blank `<think></think>` blocks to be prepended to real thoughts in chat history.
-> 7. **Restored Fast Mode:** Replaced official 3.8's hard exception on `enable_thinking=false`, restoring full user freedom to disable reasoning via kwargs or `<|think_off|>`.
-> 8. **Universal Tool Arguments:** Hardened tool call parsing to handle both dictionary structures and JSON-serialized strings without crashing.
-> 9. **Diagnostic Utility:** Added `scripts/check_applied.py` to inspect model folders and GGUFs for template consistency.
-
-> **2026-08-13 Update (v22): Qwen 3.8 Support, Reasoning Effort Controls, and Engine Hardening.** 
-
-> **2026-07-02 Update (v21.3): Optional JSON Tool Format Kwarg.** Added an optional `tool_call_format="json"` override for `chat_template_kwargs`.
-
-> **2026-07-02 Update (v21.2): Reasoning Bypass Hallucination Fix.** Adjusted `<IMPORTANT>` block instructions to remove explicit mentions of `</think>` during tool definitions.
-
-> **2026-07-02 Update (v21.1): Reliability Overhaul & XML Revert.** Reverted to native XML format for vLLM `qwen3_coder` compatibility and restored `preserve_thinking` default to `true`.
-
-</details>

archive/README-v22.2.md

@@ -1,296 +0,0 @@
----
-license: apache-2.0
-tags:
-  - jinja
-  - chat-template
-  - qwen
-  - qwen3.5
-  - qwen3.6
-  - qwen3.8
-  - lm-studio
-  - mlx
-  - llama.cpp
-  - vllm
-  - tool-calling
-  - thinking
----
-
-# Fixed jinja chat templates for Qwen 3.5, 3.6 & 3.8 (v22.2)
-
-This is a universal drop-in Jinja template that fixes rendering errors, KV cache invalidation, token waste, empty think poisoning, and fatal agentic stalling across official Qwen chat templates.
-
-It works across LM Studio, llama.cpp, vLLM, MLX, oMLX, KoboldCPP, and any engine that supports Hugging Face Jinja templates. You only need the single `chat_template.jinja` file at the root of this repository for all Qwen 3.5, 3.6, and 3.8 model sizes.
-
----
-
-## What is New with Qwen 3.8 (v22 / v22.1 / v22.2)
-
-Qwen 3.8 introduces prompt-steered reasoning depth and new model architectures (`Qwen3.8-2.4T-A95B`, `Qwen3.8-27B`). While the official template added reasoning effort steering, it also introduced several lockdowns, regressions, and syntax crashes.
-
-The v22 generation delivers full Qwen 3.8 support with all official bugs resolved:
-
-| Feature / Fix | Official Qwen 3.8 Template | This Template (v22.2) |
-|---|---|---|
-| **Default Reasoning Baseline** | Hardcodes `xhigh` by default, often exhausting the token budget on reasoning before generating answers. | Defaults to `medium` (zero injected tokens), preserving KV cache parity with v21 and preventing empty-content timeouts. |
-| **Non-Reasoning Fast Mode** | Throws a fatal exception if `enable_thinking=false`. | Full non-reasoning mode restored via kwargs (`enable_thinking=false`, `reasoning_effort="none"`) or inline `<\|think_off\|>`. |
-| **History Reasoning Extraction** | Drops in-content thinking extraction, prepending blank `<think></think>` blocks to real thoughts in chat history. | Extracts reasoning across OpenAI (`reasoning_content`), Anthropic (`thinking`), and in-content tags (`<think>`) without tag duplication. |
-| **Tool Argument Wire Format** | Crashes on serialized JSON strings from standard OpenAI API clients. | Canonical XML default with universal argument handling: safely renders stringified JSON arguments in history without syntax crashes or KV cache invalidation. |
-| **Client Reasoning Aliases** | Rejects non-standard effort names. | Maps OpenAI, Claude Code, Cursor, and Cline aliases automatically: `high`, `max`, `ultracode`, `extreme` $\to$ `xhigh`; `minimal` $\to$ `low`; `none`, `off` $\to$ disabled. |
-| **Per-Turn Inline Chat Tags** | Not supported. | Inline steering via chat text: `<\|think_low\|>`, `<\|think_medium\|>`, `<\|think_xhigh\|>`, `<\|think_ultracode\|>`, `<\|think_off\|>`. Tags are stripped before inference. |
-| **Leading System Prompts** | Treats multiple leading system messages as separate turns. | Merges consecutive leading `system` and `developer` messages into a single system turn joined by double newlines. |
-| **Tool Error Recovery** | Not supported or triggers false warnings on search results containing words like "error". | Two-tier error recovery with smart code/grep disambiguation to avoid false warnings on search results like `throw new Error(...)`. |
-| **llama.cpp Flag Support** | Requires manual template kwargs. | Native alias support for `--reasoning-preserve` CLI flag via `preserve_reasoning`. |
-| **Diagnostic Tool** | None provided. | Includes `scripts/check_applied.py` to inspect model directories and GGUFs for active template versions. |
-
----
-
-<details open>
-<summary><b>Quick Install & Engine Setup</b></summary>
-
-### llama.cpp / llama-server / koboldcpp
-Run `llama-server` with the template file and DeepSeek reasoning format:
-```bash
-llama-server -m your_model.gguf --jinja --chat-template-file chat_template.jinja --reasoning-format deepseek
-```
-*Why `--reasoning-format deepseek` matters:* When connecting coding agents like OpenCode, Claude Code, or Pi.dev to `llama-server`, this flag extracts `<think>` blocks into the dedicated `reasoning_content` API response field. This prevents raw thinking tokens from leaking into the text stream and stopping tool calls midway.
-
-*Native CLI flag:* On recent `llama.cpp` builds, you can pass `--reasoning-preserve` directly to ensure 100% Prefix KV Cache retention.
-
-### LM Studio
-1. Open your Qwen model in the right side panel.
-2. Scroll down to **Prompt Template**.
-3. Replace the template with the contents of `chat_template.jinja`.
-4. Click **Save**.
-
-### vLLM
-Replace the `"chat_template"` string in your `tokenizer_config.json` with `chat_template_oneline.txt` (or raw `chat_template.jinja`).
-```bash
-vllm serve Qwen/Qwen3.8-2.4T-A95B --tool-call-parser qwen3_xml
-```
-*Parser selection:* Use `--tool-call-parser qwen3_xml` on current vLLM releases. If you are on an older vLLM build, use `--tool-call-parser qwen3_coder`. If you explicitly set `tool_call_format="json"`, use `--tool-call-parser hermes`.
-
-### oMLX / MLX
-Overwrite `chat_template.jinja` in your local model directory and launch with `--jinja`.
-
-</details>
-
----
-
-## Why you need this
-
-The official Qwen templates contain engine restrictions, Python-specific Jinja logic, and regressions that break local inference and agent workflows.
-
-<details open>
-<summary><b>Critical Issues Fixed</b></summary>
-
-| Area | Issue in Official Templates | The Fix |
-|---|---|---|
-| **Qwen 3.8 Support** | Official 3.8 crashes if `enable_thinking=false`. | **Restored Fast Mode**. Supports fast non-reasoning mode via kwargs or `<\|think_off\|>`. |
-| **Qwen 3.8 Token Safety** | Official `xhigh` default burns token budgets with zero content returned. | **Safe `medium` Default**. Zero prompt injection unless explicitly requested. |
-| **Qwen 3.8 Regression** | Official 3.8 injects duplicate blank `<think></think>` in chat history. | **Cured Empty Think Poisoning**. Robust multi-format reasoning extraction. |
-| **Reasoning Control** | Inability to change reasoning effort in chat interfaces. | **Inline Chat Tags**. Full support for `<\|think_low\|>`, `<\|think_medium\|>`, and `<\|think_xhigh\|>`. |
-| **Compatibility** | `llama.cpp --reasoning-preserve` CLI flag compatibility. | **Native Alias Support**. Supports both `preserve_reasoning` and `preserve_thinking`. |
-| **Compatibility** | JSON-string tool arguments (OpenAI / Ollama) crash official templates. | **Universal Tool Parsing**. Safely handles mappings, JSON strings, and scalar args. |
-| **Agentic Loop** | Model aborts turn when combining conversational text and a tool call. | Cured "Empty Think" poisoning and softened imperative system directives. |
-| **Agentic Loop** | Model gets stuck emitting the identical failing tool call. | Added two-tier error escalation to force correction while retaining reasoning. |
-| **Agentic Loop** | Model panics and debates internal rules after fetching data. | Broadened `<think>` instructions to authorize conversational synthesis. |
-| **Agentic Loop** | API returns containing the word "error" trigger false retry loops. | Replaced broad matching with strict structural guards. |
-| **Performance** | Mutated past turns destroy the prefix cache. | Enforced chronological history for a 100% KV Cache hit rate. |
-| **Performance** | Deep Jinja nesting drops `llama.cpp` speed by 80%. | Flattened the AST architecture to maximize throughput. |
-| **Compatibility** | Python-specific filters crash C++ inference engines. | Rewrote all filters to be 100% `minijinja` safe. |
-| **Compatibility** | Qwen-native parsers (like vLLM) crash on JSON formatting. | Maintained canonical Qwen XML format as the default. |
-| **Compatibility** | Older API setups and wrappers crash on native XML. | Added a `tool_call_format="json"` opt-in override. |
-| **Compatibility** | Anthropic `message.thinking` payloads are rejected. | Added native Anthropic reasoning support. |
-| **Stability** | Massive tool data returns blow out the context window. | Added dynamic payload truncation limits. |
-| **Stability** | Mid-conversation system prompts crash the template. | Added native support for arbitrary system and developer messages. |
-| **Edge Cases** | Text duplicates during streaming generation. | Restored canonical spacing to the generation prompt. |
-| **Edge Cases** | Model hallucinates reasoning tags when thinking is disabled. | Injected strict boundaries to force clean reasoning bypass. |
-
-</details>
-
----
-
-## Customization & Kwarg Reference
-
-<details open>
-<summary><b>1. Reasoning Effort Steering (Qwen 3.8)</b></summary>
-
-Qwen 3.8 has 3 native prompt-steered reasoning levels. You can control this via template kwargs or directly inline in your chat messages:
-
-**Via Template Kwargs (`chat_template_kwargs`):**
-```json
-{
-  "reasoning_effort": "xhigh"
-}
-```
-* **`"medium"` (Default / Safe Baseline):** No extra instruction text injected. Preserves 100% Prefix KV Cache parity with v21 and lets the model reason naturally without token-budget traps.
-* **`"xhigh"` (Deep Reasoning):** Injects Qwen's official deep reasoning instruction:
-  > *"Reasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer."*
-* **`"low"` (Concise Reasoning):** Injects concise thinking instructions for fast, summary-oriented reasoning:
-  > *"Reasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration."*
-
-*API Compatibility Aliases:*
-To prevent errors when calling the model through standard API proxies and coding agent harnesses:
-* `"high"`, `"max"`, `"ultracode"`, and `"extreme"` automatically map to `"xhigh"` (supported by OpenAI, Claude Code, Cline, Cursor).
-* `"minimal"` and `"low"` automatically map to `"low"`.
-* `"none"` and `"off"` disable thinking entirely.
-
-**Via Inline Chat Tags (Per-Prompt Steering):**
-* `Solve this proof <|think_xhigh|>` or `<|think_ultracode|>` (Deep reasoning)
-* `Explain recursion briefly <|think_low|>` (Concise reasoning)
-* `What is the capital of France? <|think_off|>` (No reasoning / fast mode)
-
-*(Note: When thinking is disabled, reasoning effort instructions are automatically suppressed).*
-
-</details>
-
-<details>
-<summary><b>2. KV Cache Preservation (`preserve_reasoning` & `preserve_thinking`)</b></summary>
-
-By default, this template **preserves** all past `<think>` blocks in the chat history. This prevents the model from suffering "amnesia stalls" during complex agentic loops and guarantees a 100% Prefix KV Cache hit rate on local inference engines.
-
-* On recent `llama.cpp` builds, pass `--reasoning-preserve` directly.
-* Or pass via template kwargs:
-```json
-{
-  "preserve_thinking": true
-}
-```
-
-If you are on severely memory-constrained hardware and need to save context tokens, set `"preserve_thinking": false` (or `"preserve_reasoning": false`) to strip past thoughts.
-
-</details>
-
-<details>
-<summary><b>3. Tool Call Format (XML vs JSON)</b></summary>
-
-Qwen models are natively trained on XML tool calls (`<function=name>`). By default, this template uses **`xml`** format:
-* **`"xml"` (Default):** Generates canonical XML instructions for tool calls and safely handles both dictionary arguments and serialized JSON strings in assistant history without corrupting XML tags or mutating system prompts between turns.
-* **`"json"` (Optional Override):** Forces Hermes JSON format (`{"name": "...", "arguments": {...}}`) for both system prompt instructions and history rendering.
-
-**When to use the JSON override:**
-If you are using a framework or harness (such as specific Hermes Agent configurations) that strictly requires Hermes JSON, pass:
-```json
-{
-  "tool_call_format": "json"
-}
-```
-*(When opting into JSON format, argument truncation is safely bypassed to avoid corrupting JSON syntax)*.
-
-</details>
-
-<details>
-<summary><b>4. Dynamic Payload Truncation</b></summary>
-
-To prevent oversized tool returns from blowing out context limits:
-* `max_tool_arg_chars` (default `0` / disabled): Slices oversized tool call arguments.
-* `max_tool_response_chars` (default `0` / disabled): Slices oversized tool output data.
-
-</details>
-
----
-
-<details>
-<summary><b>Diagnostic Script & Test Suite</b></summary>
-
-### Check Active Template on Your Model
-Run the included diagnostic utility on your model folder or GGUF:
-```bash
-python3 scripts/check_applied.py /path/to/your/model
-```
-
-### Running the Test Suite
-```bash
-python3 scripts/test_v22.py
-```
-Tests cover 44 automated verification cells including `reasoning_effort` levels, monotonic API mappings, inline chat tags, multi-part payloads, tool call serialization, dynamic truncation, error escalation, multi-turn history parsing, and KV cache stability.
-
-</details>
-
----
-
-## Authorship
-| Role | Author |
-|------|--------|
-| Original models | Alibaba Cloud (Qwen team) |
-| Template fixes | [froggeric](https://huggingface.co/froggeric) |
-| C++ AST optimizations | [barubary](https://github.com/spiritbuun/buun-llama-cpp) / `spiritbuun` |
-
-## License
-Apache-2.0, inherited from Qwen.
-
----
-
-<details>
-<summary>Technical Details of the Critical Fixes</summary>
-
-### 1. The "Empty Think" Poisoning and Logic Trap Cure
-Previous templates attempted to save tokens by replacing past thoughts with empty `<think>\n</think>` blocks, combined with an absolute system prompt demanding a tool be called immediately after `</think>`. This created a toxic pattern where the model associated empty thoughts with tools, causing an 80%+ premature turn abort rate. We abolished empty think injection and rewrote the `<IMPORTANT>` directives to explicitly authorize conversational synthesis after thinking. In this release, we also cured official Qwen 3.8's history bug where missing in-content parsers created duplicate blank think tags.
-
-### 2. Upfront Pre-Scan for Control Tags & Inline Effort Steering
-In Jinja templates, system prompts are assembled before iterating over message history. We introduce a comprehensive upfront pre-scan covering raw strings, string lists, and multi-part content lists (`[{'type': 'text', 'text': '...'}]`). This resolves `<|think_off|>`, `<|think_on|>`, `<|think_low|>`, `<|think_medium|>`, and `<|think_xhigh|>` states before the system message is built, ensuring reasoning instructions are never injected into non-reasoning turns and all tags are cleanly stripped during rendering.
-
-### 3. KV Cache Safety and Autoregressive Normalization
-Llama.cpp and vLLM utilize prefix KV caching to speed up generation. Because this template preserves historical thoughts chronologically by default and defaults `reasoning_effort` to `medium` (zero system tokens), rendered history perfectly synchronizes with cached generated tokens. Combined with strict single newline normalization at autoregressive boundaries, this achieves a 100% KV Cache hit rate in multi-turn sessions.
-
-### 4. Native XML Tool Format and Universal Serialization
-The model was trained with the XML tool format used by Qwen3-Coder. We restored this format natively while bypassing the `|items` crash by handling both mapping dictionaries and JSON strings. This eliminates crashes when standard OpenAI proxies pass stringified arguments.
-
-### 5. Two-Tier Agentic Error Escalation
-When a tool call fails validation repeatedly, the model can enter a degenerate reasoning spiral. This template leverages a two-tier escalation system driven by a forward-tracked `consecutive_failures` counter. On the first error, a diagnostic warning is injected. On the second consecutive error, an urgent system warning forces a fundamentally different approach while retaining the reasoning block so the model can plan its correction.
-
-### 6. Smart False-Positive Detection
-Instead of broad substring matching that triggers false retry loops on successful database returns containing words like "error", this template utilizes strict structural guards looking for `Exception:`, `"error":`, `Traceback`, and `command not found`, combined with length gates and shell echo exclusions (`$ `).
-
-### 7. minijinja Compatibility Constraints
-Python-only Jinja2 features crash or misbehave on `minijinja` (the C++ runtime used by llama.cpp, LM Studio, and MLX). All instances have been refactored for universal support:
-* `content | replace('<|think_on|>', '')` became `content.split('<|think_on|>') | join('')` (fixes a bug where `minja` silently drops the entire text payload if the replaced string is found at index 0).
-* `| items` became `for key in mapping`.
-* `loop.previtem` became explicit array indexing.
-* `map('string')` became `join('|')`.
-* `| first` became `'$ ' in content`.
-
-### 8. AST Flattening for C++ Throughput
-Deeply nested Jinja loops and macros create severe parsing bottlenecks in C++ inference engines. We flattened the AST architecture, effectively curing an 80% inference throughput drop on `llama.cpp` by streamlining how `ns_state` tracking and historical rendering loops are evaluated.
-
-### 9. Dynamic Payload Truncation
-Massive API or database returns can instantly blow out a model's context window. We implemented `max_tool_arg_chars` and `max_tool_response_chars` limiters that safely slice oversized payloads. Crucially, this truncation is automatically disabled when `tool_call_format="json"` is active, as slicing a serialized JSON string structurally corrupts the data and crashes downstream parsers.
-
-### 10. Reasoning Bypass Hallucination Mitigation
-When thinking is disabled, Qwen models often hallucinate reasoning tags due to their training bias. We injected a safe boundary and adjusted the `<IMPORTANT>` system block to remove explicit mentions of `</think>` during tool instructions. This stops the model from hallucinating closing tags when calling tools in a no-reasoning state.
-
-</details>
-
----
-
-<details>
-<summary>Update History & Changelog</summary>
-
-> **2026-08-19 Update (v22.2): Extended Effort Aliases, String Argument Safety, and Error Disambiguation.**
-> 1. **Universal Tool Argument Handling:** Hardened XML tool argument parsing to safely handle both mappings and serialized JSON strings in assistant history without syntax crashes or KV cache mutation.
-> 2. **Reasoning Effort Aliases:** Added `"ultracode"` and `"extreme"` mappings to `'xhigh'`, with inline `<|think_ultracode|>` and `<|think_extreme|>` support (#78).
-> 3. **Multi-System Message Merging:** Merged consecutive leading `system` and `developer` messages into a single unified system turn with `\n\n`.
-> 4. **Grep / Search Error Disambiguation:** Eliminated false-positive tool error warnings on code search results containing patterns like `throw new Error` or `console.error` (#66).
-> 5. **Safe XML Primitive Serialization:** Boolean and null XML parameter values now serialize to `true`, `false`, and `null` via `| tojson`.
-> 6. **Zero-Crash Resilience:** Maintained full resilience without fatal `raise_exception` aborts across all runtime engines.
-
-> **2026-08-16 Update (v22.1): The Qwen 3.8 Update (Bounded Reasoning Defaults, Inline Chat Tags, and Diagnostic Utility).**
-> 1. **Full Qwen 3.8 Support:** Single drop-in template covering all Qwen 3.5, 3.6, and 3.8 model variants (`Qwen3.8-2.4T-A95B`, `Qwen3.8-27B`).
-> 2. **Default `reasoning_effort` to `medium`:** Replaced the unsafe `xhigh` default with `medium` (zero injected tokens). Eliminates the runaway reasoning token-burn failure where models explore branches until hitting `max_tokens` with empty content (#72).
-> 3. **Inline Chat Tags:** Added support for `<|think_low|>`, `<|think_medium|>`, and `<|think_xhigh|>` tags directly inside chat messages (#70).
-> 4. **API Mapping & Aliasing:** Added case-insensitive alias support for client and serving runtimes (`high`/`max` -> `xhigh`, `minimal` -> `low`, `none` -> thinking off).
-> 5. **Sequential Control Tag Stripping:** Ensured all 7 control tags are cleanly stripped across system, user, and multi-part content without prompt leakage.
-> 6. **Cured Official 3.8 Empty Think Bug:** Fixed a regression in the official Qwen 3.8 template where removing `<think>` extraction caused blank `<think></think>` blocks to be prepended to real thoughts in chat history.
-> 7. **Restored Fast Mode:** Replaced official 3.8's hard exception on `enable_thinking=false`, restoring full user freedom to disable reasoning via kwargs or `<|think_off|>`.
-> 8. **Universal Tool Arguments:** Hardened tool call parsing to handle both dictionary structures and JSON-serialized strings without crashing.
-> 9. **Diagnostic Utility:** Added `scripts/check_applied.py` to inspect model folders and GGUFs for template consistency.
-
-> **2026-08-13 Update (v22): Qwen 3.8 Support, Reasoning Effort Controls, and Engine Hardening.** 
-
-> **2026-07-02 Update (v21.3): Optional JSON Tool Format Kwarg.** Added an optional `tool_call_format="json"` override for `chat_template_kwargs`.
-
-> **2026-07-02 Update (v21.2): Reasoning Bypass Hallucination Fix.** Adjusted `<IMPORTANT>` block instructions to remove explicit mentions of `</think>` during tool definitions.
-
-> **2026-07-02 Update (v21.1): Reliability Overhaul & XML Revert.** Reverted to native XML format for vLLM `qwen3_coder` compatibility and restored `preserve_thinking` default to `true`.
-
-</details>

archive/README-v22.3.md

@@ -1,317 +0,0 @@
----
-license: apache-2.0
-tags:
-  - jinja
-  - chat-template
-  - qwen
-  - qwen3.5
-  - qwen3.6
-  - qwen3.8
-  - lm-studio
-  - mlx
-  - llama.cpp
-  - vllm
-  - tool-calling
-  - thinking
----
-
-# Fixed jinja chat templates for Qwen 3.5, 3.6 & 3.8 (v22.3)
-
-This is a universal drop-in Jinja template that fixes rendering errors, KV cache invalidation, token waste, empty think poisoning, and fatal agentic stalling across official Qwen chat templates.
-
-It works across LM Studio, llama.cpp, vLLM, MLX, oMLX, KoboldCPP, and any engine that supports Hugging Face Jinja templates. You only need the single `chat_template.jinja` file at the root of this repository for all Qwen 3.5, 3.6, and 3.8 model sizes.
-
----
-
-## What is New with Qwen 3.8 (v22 / v22.1 / v22.2 / v22.3)
-
-Qwen 3.8 introduces prompt-steered reasoning depth and new model architectures (`Qwen3.8-2.4T-A95B`, `Qwen3.8-27B`). While the official template added reasoning effort steering, it also introduced several lockdowns, regressions, and syntax crashes.
-
-The v22 generation delivers full Qwen 3.8 support with all official bugs resolved:
-
-| Feature / Fix | Official Qwen 3.8 Template | This Template (v22.3) |
-|---|---|---|
-| **Default Reasoning Baseline** | Hardcodes `xhigh` by default, often exhausting the token budget on reasoning before generating answers. | Defaults to `medium` (zero injected tokens), preserving KV cache parity with v21 and preventing empty-content timeouts. |
-| **Non-Reasoning Fast Mode** | Throws a fatal exception if `enable_thinking=false`. | Full non-reasoning mode restored via kwargs (`enable_thinking=false`, `reasoning_effort="none"`) or inline `<\|think_off\|>`. |
-| **History Reasoning Extraction** | Drops in-content thinking extraction, prepending blank `<think></think>` blocks to real thoughts in chat history. | Extracts reasoning across OpenAI (`reasoning_content`), Anthropic (`thinking`), and in-content tags (`<think>`) without tag duplication. |
-| **Tool Argument Wire Format** | Crashes on serialized JSON strings from standard OpenAI API clients. | Canonical XML default with universal argument handling: safely renders stringified JSON arguments in history without syntax crashes or KV cache invalidation. |
-| **Client Reasoning Aliases** | Rejects non-standard effort names. | Maps OpenAI, Claude Code, Cursor, and Cline aliases automatically: `high`, `max`, `ultracode`, `extreme` $\to$ `xhigh`; `minimal` $\to$ `low`; `none`, `off` $\to$ disabled. |
-| **Per-Turn Inline Chat Tags** | Not supported. | Inline steering via chat text: `<\|think_low\|>`, `<\|think_medium\|>`, `<\|think_xhigh\|>`, `<\|think_ultracode\|>`, `<\|think_off\|>`. Tags are stripped before inference. |
-| **Leading System Prompts** | Treats multiple leading system messages as separate turns. | Merges consecutive leading `system` and `developer` messages into a single system turn joined by double newlines. |
-| **Tool Error Recovery** | Not supported or triggers false warnings on search results containing words like "error". | Two-tier error recovery with smart code/grep disambiguation to avoid false warnings on search results like `throw new Error(...)`. Structural signals escalate on payloads of any size. |
-| **llama.cpp Flag Support** | Requires manual template kwargs. | Native alias support for `--reasoning-preserve` CLI flag via `preserve_reasoning`. |
-| **Diagnostic Tool** | None provided. | Includes `scripts/check_applied.py` to inspect model directories and GGUFs for active template versions. |
-
----
-
-<details open>
-<summary><b>Quick Install & Engine Setup</b></summary>
-
-### llama.cpp / llama-server / koboldcpp
-Run `llama-server` with the template file and DeepSeek reasoning format:
-```bash
-llama-server -m your_model.gguf --jinja --chat-template-file chat_template.jinja --reasoning-format deepseek
-```
-*Why `--reasoning-format deepseek` matters:* When connecting coding agents like OpenCode, Claude Code, or Pi.dev to `llama-server`, this flag extracts `<think>` blocks into the dedicated `reasoning_content` API response field. This prevents raw thinking tokens from leaking into the text stream and stopping tool calls midway.
-
-*Native CLI flag:* On recent `llama.cpp` builds, you can pass `--reasoning-preserve` directly for 100% Prefix KV Cache retention.
-
-### LM Studio
-1. Open your Qwen model in the right side panel.
-2. Scroll down to **Prompt Template**.
-3. Replace the template with the contents of `chat_template.jinja`.
-4. Click **Save**.
-
-### vLLM
-Replace the `"chat_template"` string in your `tokenizer_config.json` with `chat_template_oneline.txt` (or raw `chat_template.jinja`).
-```bash
-vllm serve Qwen/Qwen3.8-2.4T-A95B --tool-call-parser qwen3_xml
-```
-*Parser selection:* Use `--tool-call-parser qwen3_xml` on current vLLM releases. If you are on an older vLLM build, use `--tool-call-parser qwen3_coder`. If you explicitly set `tool_call_format="json"`, use `--tool-call-parser hermes`.
-
-### oMLX / MLX
-Overwrite `chat_template.jinja` in your local model directory and launch with `--jinja`.
-
-</details>
-
----
-
-## Why you need this
-
-The official Qwen templates contain engine restrictions, Python-specific Jinja logic, and regressions that break local inference and agent workflows.
-
-<details open>
-<summary><b>Critical Issues Fixed</b></summary>
-
-| Area | Issue in Official Templates | The Fix |
-|---|---|---|
-| **Qwen 3.8 Support** | Official 3.8 crashes if `enable_thinking=false`. | **Restored Fast Mode**. Supports fast non-reasoning mode via kwargs or `<\|think_off\|>`. |
-| **Qwen 3.8 Token Safety** | Official `xhigh` default burns token budgets with zero content returned. | **Safe `medium` Default**. Zero prompt injection unless explicitly requested. |
-| **Qwen 3.8 Regression** | Official 3.8 injects duplicate blank `<think></think>` in chat history. | **Cured Empty Think Poisoning**. Multi-format reasoning extraction. |
-| **Reasoning Control** | Inability to change reasoning effort in chat interfaces. | **Inline Chat Tags**. Full support for `<\|think_low\|>`, `<\|think_medium\|>`, and `<\|think_xhigh\|>`. |
-| **Compatibility** | `llama.cpp --reasoning-preserve` CLI flag compatibility. | **Native Alias Support**. Supports both `preserve_reasoning` and `preserve_thinking`. |
-| **Compatibility** | JSON-string tool arguments (OpenAI / Ollama) crash official templates. | **Universal Tool Parsing**. Safely handles mappings, JSON strings, and scalar args. |
-| **Agentic Loop** | Model aborts turn when combining conversational text and a tool call. | Cured "Empty Think" poisoning and softened imperative system directives. |
-| **Agentic Loop** | Model gets stuck emitting the identical failing tool call. | Added two-tier error escalation to force correction while retaining reasoning. |
-| **Agentic Loop** | Model panics and debates internal rules after fetching data. | Broadened `<think>` instructions to authorize conversational synthesis. |
-| **Agentic Loop** | API returns containing the word "error" trigger false retry loops. | Replaced broad matching with strict structural guards. |
-| **Performance** | Mutated past turns destroy the prefix cache. | Enforced chronological history for a 100% KV Cache hit rate. |
-| **Performance** | Deep Jinja nesting drops `llama.cpp` speed by 80%. | Flattened the AST architecture to maximize throughput. |
-| **Compatibility** | Python-specific filters crash C++ inference engines. | Rewrote all filters to be 100% `minijinja` safe. |
-| **Compatibility** | Qwen-native parsers (like vLLM) crash on JSON formatting. | Maintained canonical Qwen XML format as the default. |
-| **Compatibility** | Older API setups and wrappers crash on native XML. | Added a `tool_call_format="json"` opt-in override. |
-| **Compatibility** | Anthropic `message.thinking` payloads are rejected. | Added native Anthropic reasoning support. |
-| **Stability** | Massive tool data returns blow out the context window. | Added dynamic payload truncation limits. |
-| **Stability** | Mid-conversation system prompts crash the template. | Added native support for arbitrary system and developer messages. |
-| **Edge Cases** | Text duplicates during streaming generation. | Restored canonical spacing to the generation prompt. |
-| **Edge Cases** | Model hallucinates reasoning tags when thinking is disabled. | Injected strict boundaries to force clean reasoning bypass. |
-
-</details>
-
----
-
-## Customization & Kwarg Reference
-
-<details open>
-<summary><b>1. Reasoning Effort Steering (Qwen 3.8)</b></summary>
-
-Qwen 3.8 has 3 native prompt-steered reasoning levels. You can control this via template kwargs or directly inline in your chat messages:
-
-**Via Template Kwargs (`chat_template_kwargs`):**
-```json
-{
-  "reasoning_effort": "xhigh"
-}
-```
-* **`"medium"` (Default / Safe Baseline):** No extra instruction text injected. Preserves 100% Prefix KV Cache parity with v21 and lets the model reason naturally without token-budget traps.
-* **`"xhigh"` (Deep Reasoning):** Injects Qwen's official deep reasoning instruction:
-  > *"Reasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer."*
-* **`"low"` (Concise Reasoning):** Injects concise thinking instructions for fast, summary-oriented reasoning:
-  > *"Reasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration."*
-
-*API Compatibility Aliases:*
-To prevent errors when calling the model through standard API proxies and coding agent harnesses:
-* `"high"`, `"max"`, `"ultracode"`, and `"extreme"` automatically map to `"xhigh"` (supported by OpenAI, Claude Code, Cline, Cursor).
-* `"minimal"` and `"low"` automatically map to `"low"`.
-* `"none"` and `"off"` disable thinking entirely.
-
-**Via Inline Chat Tags (Per-Prompt Steering):**
-* `Solve this proof <|think_xhigh|>` or `<|think_ultracode|>` (Deep reasoning)
-* `Explain recursion briefly <|think_low|>` (Concise reasoning)
-* `What is the capital of France? <|think_off|>` (No reasoning / fast mode)
-
-*(Note: When thinking is disabled, reasoning effort instructions are automatically suppressed).*
-
-</details>
-
-<details>
-<summary><b>2. KV Cache Preservation (`preserve_reasoning` & `preserve_thinking`)</b></summary>
-
-By default, this template **preserves** all past `<think>` blocks in the chat history. This prevents the model from suffering "amnesia stalls" during complex agentic loops and guarantees a 100% Prefix KV Cache hit rate on local inference engines.
-
-* On recent `llama.cpp` builds, pass `--reasoning-preserve` directly.
-* Or pass via template kwargs:
-```json
-{
-  "preserve_thinking": true
-}
-```
-
-If you are on severely memory-constrained hardware and need to save context tokens, set `"preserve_thinking": false` (or `"preserve_reasoning": false`) to strip past thoughts.
-
-> **KV cache trade-off:** `preserve_thinking: false` keeps reasoning only for the turns that follow the most recent user query, so historical thoughts are dropped as soon as a new user turn begins. That rewrites already-rendered history and invalidates the prefix cache from the first assistant turn of the previous segment. The 100% Prefix KV Cache hit rate applies to the default (`true`) setting; enable stripping only when context pressure outweighs prompt reprocessing cost.
-
-</details>
-
-<details>
-<summary><b>3. Tool Call Format (XML vs JSON)</b></summary>
-
-Qwen models are natively trained on XML tool calls (`<function=name>`). By default, this template uses **`xml`** format:
-* **`"xml"` (Default):** Generates canonical XML instructions for tool calls and safely handles both dictionary arguments and serialized JSON strings in assistant history without corrupting XML tags or mutating system prompts between turns.
-* **`"json"` (Optional Override):** Forces Hermes JSON format (`{"name": "...", "arguments": {...}}`) for both system prompt instructions and history rendering.
-
-**When to use the JSON override:**
-If you are using a framework or harness (such as specific Hermes Agent configurations) that strictly requires Hermes JSON, pass:
-```json
-{
-  "tool_call_format": "json"
-}
-```
-*(When opting into JSON format, both argument and tool response truncation are bypassed to avoid corrupting JSON syntax)*.
-
-</details>
-
-<details>
-<summary><b>4. Dynamic Payload Truncation</b></summary>
-
-To prevent oversized tool returns from blowing out context limits:
-* `max_tool_arg_chars` (default `0` / disabled): Slices oversized tool call arguments. Applies to mapping arguments and to serialized JSON string arguments alike.
-* `max_tool_response_chars` (default `0` / disabled): Slices oversized tool output data.
-
-Both limiters are disabled automatically when `tool_call_format="json"` is active, since slicing serialized JSON corrupts the payload for downstream parsers.
-
-</details>
-
----
-
-<details>
-<summary><b>Diagnostic Script & Test Suite</b></summary>
-
-### Check Active Template on Your Model
-Run the included diagnostic utility on your model folder or GGUF:
-```bash
-python3 scripts/check_applied.py /path/to/your/model
-```
-
-### Running the Test Suite
-```bash
-python3 scripts/test_v22.py
-```
-Tests cover 101 automated verification cells including `reasoning_effort` levels, monotonic API mappings, inline chat tags, multi-part and vision payloads, tool call serialization across wire formats, dynamic truncation, error escalation precision, malformed input handling, multi-turn history parsing, prefix KV cache stability, and parity between `chat_template.jinja` and `chat_template_oneline.txt`. Set `QWEN_TEMPLATE_FILE=chat_template_oneline.txt` to run the entire suite against the minified build. Test 101 is a deterministic property fuzzer (`scripts/fuzz_template.py`) asserting nine structural invariants over generated conversations; run it standalone with `python3 scripts/fuzz_template.py --cases 2000`.
-
-</details>
-
----
-
-## Authorship
-| Role | Author |
-|------|--------|
-| Original models | Alibaba Cloud (Qwen team) |
-| Template fixes | [Frédéric Guigand](https://huggingface.co/froggeric) (`@froggeric`) |
-| Property fuzzer, error tiering & test suite | [Juan Calderon-Perez](https://huggingface.co/g-a-b-y) (`@g-a-b-y`) |
-| C++ AST optimizations | [barubary](https://github.com/spiritbuun/buun-llama-cpp) / `spiritbuun` |
-
-## License
-Apache-2.0, inherited from Qwen.
-
----
-
-<details>
-<summary>Technical Details of the Critical Fixes</summary>
-
-### 1. The "Empty Think" Poisoning and Logic Trap Cure
-Previous templates attempted to save tokens by replacing past thoughts with empty `<think>\n</think>` blocks, combined with an absolute system prompt demanding a tool be called immediately after `</think>`. This created a toxic pattern where the model associated empty thoughts with tools, causing an 80%+ premature turn abort rate. We abolished empty think injection and rewrote the `<IMPORTANT>` directives to explicitly authorize conversational synthesis after thinking. In this release, we also cured official Qwen 3.8's history bug where missing in-content parsers created duplicate blank think tags.
-
-### 2. Upfront Pre-Scan for Control Tags & Inline Effort Steering
-In Jinja templates, system prompts are assembled before iterating over message history. We introduce an upfront pre-scan covering raw strings, string lists, and multi-part content lists (`[{'type': 'text', 'text': '...'}]`). This resolves `<|think_off|>`, `<|think_on|>`, `<|think_low|>`, `<|think_medium|>`, and `<|think_xhigh|>` states before the system message is built, preventing reasoning instructions from being injected into non-reasoning turns and cleanly stripping all tags during rendering.
-
-### 3. KV Cache Safety and Autoregressive Normalization
-Llama.cpp and vLLM utilize prefix KV caching to speed up generation. Because this template preserves historical thoughts chronologically by default and defaults `reasoning_effort` to `medium` (zero system tokens), rendered history perfectly synchronizes with cached generated tokens. Combined with strict single newline normalization at autoregressive boundaries, this achieves a 100% KV Cache hit rate in multi-turn sessions.
-
-### 4. Native XML Tool Format and Universal Serialization
-The model was trained with the XML tool format used by Qwen3-Coder. We restored this format natively while bypassing the `|items` crash by handling both mapping dictionaries and JSON strings. This eliminates crashes when standard OpenAI proxies pass stringified arguments.
-
-### 5. Two-Tier Agentic Error Escalation
-When a tool call fails validation repeatedly, the model can enter a degenerate reasoning spiral. This template leverages a two-tier escalation system driven by a forward-tracked `consecutive_failures` counter. On the first error, a diagnostic warning is injected. On the second consecutive error, an urgent system warning forces a fundamentally different approach while retaining the reasoning block so the model can plan its correction.
-
-### 6. Smart False-Positive Detection
-Instead of broad substring matching that triggers false retry loops on successful database returns containing words like "error", this template utilizes strict structural guards evaluated over the first 120 characters of the payload.
-
-Signals are split into two tiers. **Strong signals** are unambiguous structural markers (`"error":`, `Traceback (most recent call last):`, `command not found`, `Exception:`, `fatal:`, nonzero exit codes, `invalid syntax`) and fire unconditionally. **Weak signals** are bare prefixes (`error:`, `err!`) and remain gated by a length ceiling plus shell echo (`$ `) and timing (`took `) exclusions. Code and search results are excluded up front via `throw new`, `console.error`, `logger.error` and similar patterns.
-
-Tiering matters because the earlier flat gate suppressed every signal on payloads of 600 characters or more: a routine multi-frame Python traceback exceeds that ceiling, and any output echoing a shell prompt or a timing figure was discarded outright. Strong signals now escalate regardless of payload size.
-
-### 7. minijinja Compatibility Constraints
-Python-only Jinja2 features crash or misbehave on `minijinja` (the C++ runtime used by llama.cpp, LM Studio, and MLX). All instances have been refactored for universal support:
-* `content | replace('<|think_on|>', '')` became `content.split('<|think_on|>') | join('')` (fixes a bug where `minja` silently drops the entire text payload if the replaced string is found at index 0).
-* `| items` became `mapping.items()` iteration, which `minijinja` implements natively.
-* `loop.previtem` became explicit array indexing.
-* `map('string')` became `join('|')`.
-* `| first` became `'$ ' in content`.
-
-### 8. AST Flattening for C++ Throughput
-Deeply nested Jinja loops and macros create severe parsing bottlenecks in C++ inference engines. We flattened the AST architecture, effectively curing an 80% inference throughput drop on `llama.cpp` by streamlining how `ns_state` tracking and historical rendering loops are evaluated.
-
-### 9. Dynamic Payload Truncation
-Massive API or database returns can instantly blow out a model's context window. We implemented `max_tool_arg_chars` and `max_tool_response_chars` limiters that safely slice oversized payloads. Argument truncation covers both mapping arguments and serialized JSON string arguments, so the OpenAI proxy wire format is limited on the same terms as native dictionaries. Both limiters are automatically disabled when `tool_call_format="json"` is active, as slicing serialized JSON structurally corrupts the data and crashes downstream parsers.
-
-### 10. Reasoning Bypass Hallucination Mitigation
-When thinking is disabled, Qwen models often hallucinate reasoning tags due to their training bias. We injected a safe boundary and adjusted the `<IMPORTANT>` system block to remove explicit mentions of `</think>` during tool instructions. This stops the model from hallucinating closing tags when calling tools in a no-reasoning state.
-
-</details>
-
----
-
-<details>
-<summary>Update History & Changelog</summary>
-
-> **2026-08-20 Update (v22.3): Error Detection Tiering, Reasoning De-duplication, and Test Suite Expansion.**
-> 1. **Two-Tier Error Signals:** Structural error markers now escalate regardless of payload size. The previous flat 600-character ceiling plus whole-body `$ ` and `took ` exclusions silently suppressed warnings on ordinary multi-frame tracebacks and on any shell transcript that echoed its command. Successful exit-code reports (`Exit code: 0`) and JSON success envelopes (`"error": null` / `false` / `""`) are excluded from the strong tier so success payloads do not escalate.
-> 2. **Reasoning De-duplication:** When `reasoning_content` or `thinking` is supplied, a leading think block in `content` is stripped so clients that populate both no longer emit two consecutive think blocks. Literal tags later in the answer (for example inside code fences) are preserved verbatim; full heuristic extraction still applies when no explicit reasoning field is present.
-> 3. **Single-Line Think Blocks:** `<think>...</think>` written without surrounding newlines is now extracted instead of leaking raw tags into rendered history.
-> 4. **Complete Argument Serialization:** Scalar and list tool arguments are serialized via `| tojson` rather than silently dropped, in both XML and JSON wire formats.
-> 5. **Consistent Truncation:** `max_tool_arg_chars` now applies to serialized JSON string arguments, and `max_tool_response_chars` is bypassed under `tool_call_format="json"` as documented.
-> 6. **KV Cache Documentation:** Documented that `preserve_thinking: false` rewrites rendered history at each new user turn and therefore voids the prefix cache guarantee, which applies to the default setting.
-> 7. **Test Suite Expansion (44 -> 101):** Added coverage for control tag and alias completeness, malformed input and exception paths, vision payloads, agentic wire-format shapes, reasoning extraction variants, error detection precision, prefix KV cache stability, and jinja/oneline build parity.
-> 8. **Property-Based Fuzz Harness:** Added `scripts/fuzz_template.py`, a deterministic conversation generator asserting nine structural invariants (render success, jinja/oneline parity, token balance, verbatim content preservation, XML parameter fidelity, JSON tool-call validity, warning precision, prefix KV stability, no-think prefill). Prefix stability is checked at generation boundaries: merged system blocks and consecutive tool-result batches are atomic, since the model only generates after a full batch is appended.
->
-> *(Credits: Huge thanks to Juan Calderon-Perez (@g-a-b-y) for their massive contributions to the v22.3 release, including the property-based fuzz harness, the two-tier error signal architecture, and extensive test coverage!)*
->
-> **2026-08-19 Update (v22.2): Extended Effort Aliases, String Argument Safety, and Error Disambiguation.**
-> 1. **Universal Tool Argument Handling:** Hardened XML tool argument parsing to safely handle both mappings and serialized JSON strings in assistant history without syntax crashes or KV cache mutation.
-> 2. **Reasoning Effort Aliases:** Added `"ultracode"` and `"extreme"` mappings to `'xhigh'`, with inline `<|think_ultracode|>` and `<|think_extreme|>` support (#78).
-> 3. **Multi-System Message Merging:** Merged consecutive leading `system` and `developer` messages into a single unified system turn with `\n\n`.
-> 4. **Grep / Search Error Disambiguation:** Eliminated false-positive tool error warnings on code search results containing patterns like `throw new Error` or `console.error` (#66).
-> 5. **Safe XML Primitive Serialization:** Boolean and null XML parameter values now serialize to `true`, `false`, and `null` via `| tojson`.
-> 6. **Zero-Crash Resilience:** Maintained full resilience without fatal `raise_exception` aborts across all runtime engines.
-
-> **2026-08-16 Update (v22.1): The Qwen 3.8 Update (Bounded Reasoning Defaults, Inline Chat Tags, and Diagnostic Utility).**
-> 1. **Full Qwen 3.8 Support:** Single drop-in template covering all Qwen 3.5, 3.6, and 3.8 model variants (`Qwen3.8-2.4T-A95B`, `Qwen3.8-27B`).
-> 2. **Default `reasoning_effort` to `medium`:** Replaced the unsafe `xhigh` default with `medium` (zero injected tokens). Eliminates the runaway reasoning token-burn failure where models explore branches until hitting `max_tokens` with empty content (#72).
-> 3. **Inline Chat Tags:** Added support for `<|think_low|>`, `<|think_medium|>`, and `<|think_xhigh|>` tags directly inside chat messages (#70).
-> 4. **API Mapping & Aliasing:** Added case-insensitive alias support for client and serving runtimes (`high`/`max` -> `xhigh`, `minimal` -> `low`, `none` -> thinking off).
-> 5. **Sequential Control Tag Stripping:** All 7 control tags are cleanly stripped across system, user, and multi-part content without prompt leakage.
-> 6. **Cured Official 3.8 Empty Think Bug:** Fixed a regression in the official Qwen 3.8 template where removing `<think>` extraction caused blank `<think></think>` blocks to be prepended to real thoughts in chat history.
-> 7. **Restored Fast Mode:** Replaced official 3.8's hard exception on `enable_thinking=false`, restoring full user freedom to disable reasoning via kwargs or `<|think_off|>`.
-> 8. **Universal Tool Arguments:** Hardened tool call parsing to handle both dictionary structures and JSON-serialized strings without crashing.
-> 9. **Diagnostic Utility:** Added `scripts/check_applied.py` to inspect model folders and GGUFs for template consistency.
-
-> **2026-08-13 Update (v22): Qwen 3.8 Support, Reasoning Effort Controls, and Engine Hardening.** 
-
-> **2026-07-02 Update (v21.3): Optional JSON Tool Format Kwarg.** Added an optional `tool_call_format="json"` override for `chat_template_kwargs`.
-
-> **2026-07-02 Update (v21.2): Reasoning Bypass Hallucination Fix.** Adjusted `<IMPORTANT>` block instructions to remove explicit mentions of `</think>` during tool definitions.
-
-> **2026-07-02 Update (v21.1): Reliability Overhaul & XML Revert.** Reverted to native XML format for vLLM `qwen3_coder` compatibility and restored `preserve_thinking` default to `true`.
-
-</details>

archive/README-v22.md

@@ -1,278 +0,0 @@
----
-license: apache-2.0
-tags:
-  - jinja
-  - chat-template
-  - qwen
-  - qwen3.5
-  - qwen3.6
-  - qwen3.8
-  - lm-studio
-  - mlx
-  - llama.cpp
-  - vllm
-  - tool-calling
-  - thinking
----
-
-# Fixed jinja chat templates for Qwen 3.5, 3.6 & 3.8 (v22)
-
-This is a universal drop-in Jinja template that fixes rendering errors, KV cache invalidation, token waste, empty think poisoning, and fatal agentic stalling across official Qwen chat templates.
-
-It works across LM Studio, llama.cpp, vLLM, MLX, oMLX, KoboldCPP, and any engine that supports Hugging Face Jinja templates. You only need the single `chat_template.jinja` file at the root of this repository for all Qwen 3.5, 3.6, and 3.8 model sizes.
-
----
-
-## What is new in v22: The Qwen 3.8 Update
-
-Qwen has released their 3.8 generation starting with `Qwen3.8-2.4T-A95B`. While the official 3.8 template adopted our default reasoning preservation, it also introduced severe regressions and rigid lockdowns that break local setups. Version 22 brings full 3.8 support while fixing these official bugs:
-
-1. **Reasoning Effort Steering:** Qwen 3.8 supports prompt-directed thinking budgets (`xhigh`, `high`, `low`, `medium`). The template injects official steering instructions into the system prompt by default (`xhigh`) and auto-suppresses them when thinking is turned off.
-2. **Restored Fast Mode (No Reasoning):** Official 3.8 throws a fatal runtime exception if you pass `enable_thinking=false`. Version 22 removes this lockdown, giving you complete freedom to disable reasoning via kwargs or inline `<|think_off|>` tags.
-3. **Cured Official 3.8 Empty Think Bug:** Official 3.8 removed the in-content thinking parser. In multi-turn chats where reasoning is stored inside message content, official 3.8 injects a blank `<think></think>` block before the real thoughts. Version 22 extracts reasoning cleanly without duplicating tags.
-4. **Universal Tool Arguments:** Official 3.8 crashes with `TypeError: Can only get item pairs from a mapping` when clients send standard OpenAI string arguments. Version 22 handles both Python dictionaries and JSON strings seamlessly.
-5. **Native llama.cpp Flag Support:** Added native support for the new `llama.cpp` `--reasoning-preserve` CLI flag via the `preserve_reasoning` alias.
-
----
-
-<details open>
-<summary><b>Quick Install & Engine Setup</b></summary>
-
-### llama.cpp / llama-server / koboldcpp
-Run `llama-server` with the template file and DeepSeek reasoning format:
-```bash
-llama-server -m your_model.gguf --jinja --chat-template-file chat_template.jinja --reasoning-format deepseek
-```
-*Why `--reasoning-format deepseek` matters:* When connecting coding agents like OpenCode, Claude Code, or Pi.dev to `llama-server`, this flag extracts `<think>` blocks into the dedicated `reasoning_content` API response field. This prevents raw thinking tokens from leaking into the text stream and stopping tool calls midway.
-
-*Native CLI flag:* On recent `llama.cpp` builds, you can pass `--reasoning-preserve` directly to ensure 100% Prefix KV Cache retention.
-
-### LM Studio
-1. Open your Qwen model in the right side panel.
-2. Scroll down to **Prompt Template**.
-3. Replace the template with the contents of `chat_template.jinja`.
-4. Click **Save**.
-
-### vLLM
-Replace the `"chat_template"` string in your `tokenizer_config.json` with `chat_template_oneline.txt` (or raw `chat_template.jinja`).
-```bash
-vllm serve Qwen/Qwen3.8-2.4T-A95B --tool-call-parser qwen3_xml
-```
-*Parser selection:* Use `--tool-call-parser qwen3_xml` on current vLLM releases. If you are on an older vLLM build, use `--tool-call-parser qwen3_coder`. If you explicitly set `tool_call_format="json"`, use `--tool-call-parser hermes`.
-
-### oMLX / MLX
-Overwrite `chat_template.jinja` in your local model directory and launch with `--jinja`.
-
-</details>
-
----
-
-## Why you need this
-
-The official Qwen templates contain engine restrictions, Python-specific Jinja logic, and regressions that break local inference and agent workflows.
-
-<details open>
-<summary><b>Critical Issues Fixed</b></summary>
-
-| Area | Issue in Official Templates | The Fix in v22 |
-|---|---|---|
-| **Qwen 3.8 Support** | Official 3.8 crashes if `enable_thinking=false`. | **Restored Fast Mode**. Supports fast non-reasoning mode via kwargs or `<\|think_off\|>`. |
-| **Qwen 3.8 Regression** | Official 3.8 injects duplicate blank `<think></think>` in chat history. | **Cured Empty Think Poisoning**. Robust multi-format reasoning extraction. |
-| **Reasoning Control** | Qwen 3.8 prompt-steered reasoning budget controls. | **Full `reasoning_effort` Support**. Supports `xhigh` (default), `high`, `medium`, and `low`. |
-| **Compatibility** | `llama.cpp --reasoning-preserve` CLI flag compatibility. | **Native Alias Support**. Supports both `preserve_reasoning` and `preserve_thinking`. |
-| **Compatibility** | JSON-string tool arguments (OpenAI / Ollama) crash official templates. | **Universal Tool Parsing**. Safely handles mappings, JSON strings, and scalar args. |
-| **Agentic Loop** | Model aborts turn when combining conversational text and a tool call. | Cured "Empty Think" poisoning and softened imperative system directives. |
-| **Agentic Loop** | Model gets stuck emitting the identical failing tool call. | Added two-tier error escalation to force correction while retaining reasoning. |
-| **Agentic Loop** | Model panics and debates internal rules after fetching data. | Broadened `<think>` instructions to authorize conversational synthesis. |
-| **Agentic Loop** | API returns containing the word "error" trigger false retry loops. | Replaced broad matching with strict structural guards. |
-| **Performance** | Mutated past turns destroy the prefix cache. | Enforced chronological history for a 100% KV Cache hit rate. |
-| **Performance** | Deep Jinja nesting drops `llama.cpp` speed by 80%. | Flattened the AST architecture to maximize throughput. |
-| **Compatibility** | Python-specific filters crash C++ inference engines. | Rewrote all filters to be 100% `minijinja` safe. |
-| **Compatibility** | Qwen-native parsers (like vLLM) crash on JSON formatting. | Maintained canonical Qwen XML format as the default. |
-| **Compatibility** | Older API setups and wrappers crash on native XML. | Added a `tool_call_format="json"` opt-in override. |
-| **Compatibility** | Anthropic `message.thinking` payloads are rejected. | Added native Anthropic reasoning support. |
-| **Stability** | Massive tool data returns blow out the context window. | Added dynamic payload truncation limits. |
-| **Stability** | Mid-conversation system prompts crash the template. | Added native support for arbitrary system and developer messages. |
-| **Edge Cases** | Text duplicates during streaming generation. | Restored canonical spacing to the generation prompt. |
-| **Edge Cases** | Model hallucinates reasoning tags when thinking is disabled. | Injected strict boundaries to force clean reasoning bypass. |
-
-</details>
-
----
-
-## Customization & Kwarg Reference
-
-<details open>
-<summary><b>1. Reasoning Effort Steering (Qwen 3.8)</b></summary>
-
-Qwen 3.8 introduces prompt-steered reasoning effort levels. You can control this via template kwargs:
-```json
-{
-  "reasoning_effort": "xhigh"
-}
-```
-* **`"xhigh"` (Default / Recommended):** Injects Qwen's official deep reasoning instruction:
-  > *"Reasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer."*
-* **`"high"`:** Mapped automatically as an alias to `"xhigh"` for OpenAI proxy compatibility.
-* **`"low"`:** Injects concise thinking instructions for fast, summary-oriented reasoning.
-* **`"medium"`:** Neutral baseline (no extra instruction text injected). Ideal for users wanting exact byte-for-byte prefix cache parity with v21 sessions.
-
-*(Note: When thinking is disabled via `<|think_off|>` or `enable_thinking=false`, reasoning effort instructions are automatically suppressed).*
-
-</details>
-
-<details>
-<summary><b>2. The Thinking Toggle & Fast Mode</b></summary>
-
-You can control model reasoning dynamically on a per-prompt basis. Insert `<|think_on|>` or `<|think_off|>` anywhere in your system or user prompt. The template intercepts the tag, strips it from the final context, and sets reasoning mode immediately.
-
-**Fast answer, no reasoning:**
-```text
-System: You are a coding assistant. <|think_off|>
-User: What is 2+2?
-```
-
-**Deep reasoning:**
-```text
-System: You are a coding assistant. <|think_on|>
-User: Implement a red-black tree in Rust.
-```
-
-*(The tag syntax uses Qwen control token delimiters so it will never collide with file paths or code, unlike old community `/think` hacks)*.
-
-</details>
-
-<details>
-<summary><b>3. KV Cache Preservation (`preserve_reasoning` & `preserve_thinking`)</b></summary>
-
-By default, this template **preserves** all past `<think>` blocks in the chat history. This prevents the model from suffering "amnesia stalls" during complex agentic loops and guarantees a 100% Prefix KV Cache hit rate on local inference engines.
-
-* On recent `llama.cpp` builds, pass `--reasoning-preserve` directly.
-* Or pass via template kwargs:
-```json
-{
-  "preserve_thinking": true
-}
-```
-
-If you are on severely memory-constrained hardware and need to save context tokens, set `"preserve_thinking": false` (or `"preserve_reasoning": false`) to strip past thoughts.
-
-</details>
-
-<details>
-<summary><b>4. Tool Call Format Override (JSON vs XML)</b></summary>
-
-Qwen models are natively trained to output tool calls in XML (`<function=name>`). By default, this template uses native XML to maximize reliability.
-
-**When to use the JSON override:**
-If you are using a framework or harness (such as specific Hermes Agent configurations) that strictly requires Hermes JSON (`{"name": "...", "arguments": {...}}`), pass:
-```json
-{
-  "tool_call_format": "json"
-}
-```
-*(When opting into JSON format, argument truncation is safely bypassed to avoid corrupting JSON syntax)*.
-
-</details>
-
-<details>
-<summary><b>5. Dynamic Payload Truncation</b></summary>
-
-To prevent oversized tool returns from blowing out context limits:
-* `max_tool_arg_chars` (default `0` / disabled): Slices oversized tool call arguments.
-* `max_tool_response_chars` (default `0` / disabled): Slices oversized tool output data.
-
-</details>
-
----
-
-<details>
-<summary><b>Running the test suite</b></summary>
-
-```bash
-python3 scripts/test_v22.py
-```
-Tests cover 28 automated verification cells including `reasoning_effort` levels, tag pre-scanning, tool call serialization, dynamic truncation, error escalation, and multi-turn history parsing.
-
-</details>
-
----
-
-## Authorship
-| Role | Author |
-|------|--------|
-| Original models | Alibaba Cloud (Qwen team) |
-| Template fixes | [froggeric](https://huggingface.co/froggeric) |
-| C++ AST optimizations | [barubary](https://github.com/spiritbuun/buun-llama-cpp) / `spiritbuun` |
-
-## License
-Apache-2.0, inherited from Qwen.
-
----
-
-<details>
-<summary>Technical Details of the Critical Fixes</summary>
-
-### 1. The "Empty Think" Poisoning and Logic Trap Cure
-Previous templates attempted to save tokens by replacing past thoughts with empty `<think>\n</think>` blocks, combined with an absolute system prompt demanding a tool be called immediately after `</think>`. This created a toxic pattern where the model associated empty thoughts with tools, causing an 80%+ premature turn abort rate. We abolished empty think injection and rewrote the `<IMPORTANT>` directives to explicitly authorize conversational synthesis after thinking. In v22, we also cured official Qwen 3.8's history bug where missing in-content parsers created duplicate blank think tags.
-
-### 2. Upfront Pre-Scan for Control Tags
-In Jinja templates, system prompts are assembled before iterating over message history. Version 22 introduces an upfront pre-scan covering both plain text and multi-part content lists (`[{'type': 'text', 'text': '...'}]`). This resolves `<|think_off|>` and `<|think_on|>` states before the system message is built, ensuring reasoning instructions are never injected into non-reasoning turns.
-
-### 3. KV Cache Safety and Autoregressive Normalization
-Llama.cpp and vLLM utilize prefix KV caching to speed up generation. Because this template preserves historical thoughts chronologically by default, rendered history perfectly synchronizes with cached generated tokens. Combined with strict single newline normalization at autoregressive boundaries, this achieves a 100% KV Cache hit rate in multi-turn sessions.
-
-### 4. Native XML Tool Format and Universal Serialization
-The model was trained with the XML tool format used by Qwen3-Coder. We restored this format natively while bypassing the `|items` crash by handling both mapping dictionaries and JSON strings. This eliminates crashes when standard OpenAI proxies pass stringified arguments.
-
-### 5. Two-Tier Agentic Error Escalation
-When a tool call fails validation repeatedly, the model can enter a degenerate reasoning spiral. This template leverages a two-tier escalation system driven by a forward-tracked `consecutive_failures` counter. On the first error, a diagnostic warning is injected. On the second consecutive error, an urgent system warning forces a fundamentally different approach while retaining the reasoning block so the model can plan its correction.
-
-### 6. Smart False-Positive Detection
-Instead of broad substring matching that triggers false retry loops on successful database returns containing words like "error", this template utilizes strict structural guards looking for `Exception:`, `"error":`, `Traceback`, and `command not found`, combined with length gates and shell echo exclusions (`$ `).
-
-### 7. minijinja Compatibility Constraints
-Python-only Jinja2 features crash or misbehave on `minijinja` (the C++ runtime used by llama.cpp, LM Studio, and MLX). All instances have been refactored for universal support:
-* `content | replace('<|think_on|>', '')` became `content.split('<|think_on|>') | join('')` (fixes a bug where `minja` silently drops the entire text payload if the replaced string is found at index 0).
-* `| items` became `for key in mapping`.
-* `loop.previtem` became explicit array indexing.
-* `map('string')` became `join('|')`.
-* `| first` became `'$ ' in content`.
-
-### 8. AST Flattening for C++ Throughput
-Deeply nested Jinja loops and macros create severe parsing bottlenecks in C++ inference engines. We flattened the AST architecture, effectively curing an 80% inference throughput drop on `llama.cpp` by streamlining how `ns_state` tracking and historical rendering loops are evaluated.
-
-### 9. Dynamic Payload Truncation
-Massive API or database returns can instantly blow out a model's context window. We implemented `max_tool_arg_chars` and `max_tool_response_chars` limiters that safely slice oversized payloads. Crucially, this truncation is automatically disabled when `tool_call_format="json"` is active, as slicing a serialized JSON string structurally corrupts the data and crashes downstream parsers.
-
-### 10. Reasoning Bypass Hallucination Mitigation
-When thinking is disabled, Qwen models often hallucinate reasoning tags due to their training bias. We injected a safe boundary and adjusted the `<IMPORTANT>` system block to remove explicit mentions of `</think>` during tool instructions. This stops the model from hallucinating closing tags when calling tools in a no-reasoning state.
-
-</details>
-
----
-
-<details>
-<summary>Update History & Changelog</summary>
-
-> **2026-08-13 Update (v22): Qwen 3.8 Support, Reasoning Effort Controls, and Engine Hardening.**
-> 1. **Qwen 3.8 Compatibility:** Added full support for the new Qwen 3.8 model family (`Qwen3.8-2.4T-A95B`).
-> 2. **Reasoning Effort Steering:** Introduced `reasoning_effort` parameter (`xhigh` [default], `high`, `medium`, `low`). Automatically injects official Qwen 3.8 steering directives and auto-suppresses them when thinking is disabled.
-> 3. **Cured Official 3.8 Empty Think Bug:** Fixed a regression in the official Qwen 3.8 template where removing `<think>` extraction caused blank `<think></think>` blocks to be prepended to real thoughts in chat history.
-> 4. **Restored Fast Mode:** Replaced official 3.8's hard exception on `enable_thinking=false`, restoring full user freedom to disable reasoning via kwargs or `<|think_off|>`.
-> 5. **llama.cpp `--reasoning-preserve` Alias:** Added native support for `preserve_reasoning` alongside `preserve_thinking`.
-> 6. **Universal Tool Argument Handling:** Hardened tool call parsing to handle both dictionary structures and JSON-serialized strings without crashing.
-> 7. **Pre-Scan Tag Gating:** Upgraded control tag pre-scanning to inspect both raw string content and multi-part content lists before assembling system instructions.
-> 8. **Retained Reasoning in Error Recovery:** Maintained the `<think>\n` generation prompt during tool failure escalation so Qwen 3.8 can plan its corrected tool call.
-
-> **2026-07-02 Update (v21.3): Optional JSON Tool Format Kwarg.** Added an optional `tool_call_format="json"` override for `chat_template_kwargs`.
-
-> **2026-07-02 Update (v21.2): Reasoning Bypass Hallucination Fix.** Adjusted `<IMPORTANT>` block instructions to remove explicit mentions of `</think>` during tool definitions.
-
-> **2026-07-02 Update (v21.1): Reliability Overhaul & XML Revert.** Reverted to native XML format for vLLM `qwen3_coder` compatibility and restored `preserve_thinking` default to `true`.
-
-> **2026-06-05 Update (v20): The Architect Patch.** Major structural update for agentic loops and C++ inference engines.
-
-> **2026-05-18 Update (v19): The Agentic Loop Cure.** Abolished "Empty Think" poisoning and restored Universal Synthesis instructions.
-
-</details>

archive/v20_chat_template.jinja

@@ -1,287 +0,0 @@
-{%- set template_version = "qwen3.6-froggeric-v20" %}
-{%- set image_count = namespace(value=0) %}
-{%- set video_count = namespace(value=0) %}
-{%- set add_vision_id = add_vision_id if add_vision_id is defined else false %}
-{%- set enable_thinking = enable_thinking if enable_thinking is defined else true %}
-{%- set auto_disable_thinking_with_tools = auto_disable_thinking_with_tools if auto_disable_thinking_with_tools is defined else false %}
-{%- set _preserve_thinking = preserve_thinking if preserve_thinking is defined else false %}
-{%- set max_tool_arg_chars = max_tool_arg_chars if max_tool_arg_chars is defined else 0 %}
-{%- set max_tool_response_chars = max_tool_response_chars if max_tool_response_chars is defined else 0 %}
-{%- set _has_tools = (tools is defined and tools and tools is iterable and tools is not mapping) %}
-{%- set ns_state = namespace(thinking=enable_thinking) %}
-{%- if auto_disable_thinking_with_tools and _has_tools %}
-    {%- set ns_state.thinking = false %}
-{%- endif %}
-{%- macro render_content(content, do_vision_count, is_system_content=false) %}
-    {%- if content is string %}
-        {{- content }}
-    {%- elif content is iterable and content is not mapping %}
-        {%- for item in content %}
-            {%- if item is mapping %}
-                {%- if item.type == 'image' or 'image' in item or 'image_url' in item %}
-                    {%- if is_system_content %}
-                        {{- raise_exception('System message cannot contain images.') }}
-                    {%- endif %}
-                    {%- if do_vision_count %}
-                        {%- set image_count.value = image_count.value + 1 %}
-                    {%- endif %}
-                    {%- if add_vision_id %}
-                        {{- 'Picture ' ~ image_count.value ~ ': ' }}
-                    {%- endif %}
-                    {{- '<|vision_start|><|image_pad|><|vision_end|>' }}
-                {%- elif item.type == 'video' or 'video' in item %}
-                    {%- if is_system_content %}
-                        {{- raise_exception('System message cannot contain videos.') }}
-                    {%- endif %}
-                    {%- if do_vision_count %}
-                        {%- set video_count.value = video_count.value + 1 %}
-                    {%- endif %}
-                    {%- if add_vision_id %}
-                        {{- 'Video ' ~ video_count.value ~ ': ' }}
-                    {%- endif %}
-                    {{- '<|vision_start|><|video_pad|><|vision_end|>' }}
-                {%- elif 'text' in item %}
-                    {{- item.text }}
-                {%- else %}
-                    {{- raise_exception('Unexpected item type in content.') }}
-                {%- endif %}
-            {%- else %}
-                {{- item | string }}
-            {%- endif %}
-        {%- endfor %}
-    {%- elif content is none or content is undefined %}
-        {{- '' }}
-    {%- else %}
-        {{- raise_exception('Unexpected content type.') }}
-    {%- endif %}
-{%- endmacro %}
-{%- if not messages %}
-    {{- raise_exception('No messages provided.') }}
-{%- endif %}
-{%- set _first_role = messages[0].role %}
-{%- if _first_role == 'system' or _first_role == 'developer' %}
-    {%- set _sys_msg = messages[0] %}
-    {%- set _msgs = messages[1:] %}
-{%- else %}
-    {%- set _sys_msg = none %}
-    {%- set _msgs = messages %}
-{%- endif %}
-{%- set _sc = '' %}
-{%- if _sys_msg is not none %}
-    {%- set _sc = render_content(_sys_msg.content, false, true) | trim %}
-    {%- if '<|think_off|>' in _sc %}
-        {%- set ns_state.thinking = false %}
-        {%- set _sc = _sc.split('<|think_off|>') | join('') | trim %}
-    {%- elif '<|think_on|>' in _sc %}
-        {%- set ns_state.thinking = true %}
-        {%- set _sc = _sc.split('<|think_on|>') | join('') | trim %}
-    {%- endif %}
-{%- endif %}
-{%- if _has_tools %}
-    {{- '<|im_start|>system\n' }}
-    {{- '# Tools\n\nYou have access to the following functions:\n\n<tools>' }}
-    {%- for tool in tools %}
-        {{- '\n' }}
-        {{- tool | tojson }}
-    {%- endfor %}
-    {{- '\n</tools>' }}
-    {%- set tool_instructions %}
-If you choose to call a function ONLY reply in the following format with NO suffix:
-
-<think>
-Brief explanation of tool call
-</think>
-<tool_call>
-<function=example_function_name>
-<parameter=example_parameter_1>
-value_1
-</parameter>
-<parameter=example_parameter_2>
-This is the value for the second parameter
-that can span
-multiple lines
-</parameter>
-</function>
-</tool_call>
-
-<IMPORTANT>
-Reminder:
-- You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user.
-- ALL explanation and reasoning MUST be placed strictly inside the <think></think> block.
-- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags.
-- If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after closing </think>. Do NOT output any conversational text before the tool call.
-- The <tool_call> and <function> tags MUST be at the very beginning of a new line, with NO spaces or indentation before them.
-- To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks.
-- If you have gathered all necessary data and do not need to call a tool, answer the question like normal and provide your final response to the user IMMEDIATELY after closing </think>.
-</IMPORTANT>
-    {%- endset %}
-    {{- '\n\n' ~ tool_instructions | trim }}
-    {%- if _sc %}
-        {{- '\n\n' + _sc }}
-    {%- endif %}
-    {{- '<|im_end|>\n' }}
-{%- else %}
-    {%- if _sc %}
-        {{- '<|im_start|>system\n' + _sc + '<|im_end|>\n' }}
-    {%- endif %}
-{%- endif %}
-{%- set _last_idx = _msgs | length - 1 %}
-{%- set ns = namespace(multi_step_tool=true, last_query_index=_last_idx) %}
-{%- for message in _msgs[::-1] %}
-    {%- set index = (_msgs | length - 1) - loop.index0 %}
-    {%- if ns.multi_step_tool and message.role == 'user' %}
-        {%- set _rc = render_content(message.content, false) | trim %}
-        {%- if not (_rc.startswith('<tool_response>') and _rc.endswith('</tool_response>')) %}
-            {%- set ns.multi_step_tool = false %}
-            {%- set ns.last_query_index = index %}
-        {%- endif %}
-    {%- endif %}
-{%- endfor %}
-{%- if ns.multi_step_tool %}
-    {%- if _last_idx > 50 %}
-        {%- set ns.last_query_index = _last_idx %}
-    {%- else %}
-        {%- set ns.last_query_index = 0 %}
-    {%- endif %}
-{%- endif %}
-{%- set ns2 = namespace(prev_role='', consecutive_failures=0) %}
-{%- for message in _msgs %}
-    {%- set is_system = (message.role == "system" or message.role == "developer") %}
-    {%- set content = render_content(message.content, true, is_system) | trim %}
-    {%- if '<|think_off|>' in content %}
-        {%- set ns_state.thinking = false %}
-        {%- set content = content.split('<|think_off|>') | join('') | trim %}
-    {%- elif '<|think_on|>' in content %}
-        {%- set ns_state.thinking = true %}
-        {%- set content = content.split('<|think_on|>') | join('') | trim %}
-    {%- endif %}
-    {%- if is_system %}
-        {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}
-    {%- elif message.role == 'user' %}
-        {%- set ns2.consecutive_failures = 0 %}
-        {{- '<|im_start|>user\n' + content + '<|im_end|>\n' }}
-    {%- elif message.role == 'assistant' %}
-        {%- set reasoning_content = '' %}
-        {%- if message.reasoning_content is defined and message.reasoning_content is not none %}
-            {%- if message.reasoning_content is string %}
-                {%- set reasoning_content = message.reasoning_content %}
-            {%- else %}
-                {%- set reasoning_content = message.reasoning_content | string %}
-            {%- endif %}
-        {%- else %}
-            {%- set _think_end = '' %}
-            {%- if '</think>' in content %}
-                {%- set _think_end = '</think>' %}
-            {%- elif '</thinking>' in content %}
-                {%- set _think_end = '</thinking>' %}
-            {%- elif '</ think>' in content %}
-                {%- set _think_end = '</ think>' %}
-            {%- elif '</think >' in content %}
-                {%- set _think_end = '</think >' %}
-            {%- endif %}
-            {%- if _think_end %}
-                {%- if _think_end == '</thinking>' %}
-                    {%- set _think_start = '<thinking>' %}
-                {%- else %}
-                    {%- set _think_start = '<think>' %}
-                {%- endif %}
-                {%- set reasoning_content = content.split(_think_end)[0].rstrip('\n') %}
-                {%- if _think_start in reasoning_content %}
-                    {%- set reasoning_content = reasoning_content.split(_think_start)[-1].lstrip('\n') %}
-                {%- endif %}
-                {%- set content = content.split(_think_end)[-1].lstrip('\n') %}
-            {%- endif %}
-        {%- endif %}
-        {%- set reasoning_content = reasoning_content | trim %}
-        {%- if (_preserve_thinking or loop.index0 > ns.last_query_index) and reasoning_content %}
-            {{- '<|im_start|>assistant\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}
-        {%- else %}
-            {{- '<|im_start|>assistant\n' + content }}
-        {%- endif %}
-        {%- if message.tool_calls is defined and message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}
-            {%- for tool_call in message.tool_calls %}
-                {%- if tool_call.function is defined and tool_call.function is not none %}
-                    {%- set tc = tool_call.function %}
-                {%- else %}
-                    {%- set tc = tool_call %}
-                {%- endif %}
-                {%- if loop.first %}
-                    {%- if content | trim %}
-                        {{- '\n\n<tool_call>\n<function=' + tc.name + '>\n' }}
-                    {%- else %}
-                        {{- '<tool_call>\n<function=' + tc.name + '>\n' }}
-                    {%- endif %}
-                {%- else %}
-                    {{- '\n\n<tool_call>\n<function=' + tc.name + '>\n' }}
-                {%- endif %}
-                {%- if tc.arguments is defined and tc.arguments is not none %}
-                    {%- if tc.arguments is mapping %}
-                        {%- for args_name, args_value in tc.arguments.items() %}
-                            {{- '<parameter=' + args_name + '>\n' }}
-                            {%- if args_value is mapping or (args_value is sequence and args_value is not string) %}
-                                {%- set _av = args_value | tojson %}
-                            {%- else %}
-                                {%- set _av = args_value | string %}
-                            {%- endif %}
-                            {%- if max_tool_arg_chars > 0 and _av | length > max_tool_arg_chars %}
-                                {{- _av[:max_tool_arg_chars] + '\n[TRUNCATED — original length ' ~ (_av | length | string) ~ ' chars]' }}
-                            {%- else %}
-                                {{- _av }}
-                            {%- endif %}
-                            {{- '\n</parameter>\n' }}
-                        {%- endfor %}
-                    {%- elif tc.arguments is string and tc.arguments %}
-                        {{- tc.arguments }}
-                    {%- endif %}
-                {%- endif %}
-                {%- if loop.last %}
-                    {{- '</function>\n</tool_call>\n' }}
-                {%- else %}
-                    {{- '</function>\n</tool_call>' }}
-                {%- endif %}
-            {%- endfor %}
-        {%- endif %}
-        {{- '<|im_end|>\n' }}
-    {%- elif message.role == 'tool' %}
-        {%- set _content_lower = content | lower %}
-        {%- if content | length < 500 and '$ ' not in content and 'took ' not in _content_lower and ('"error":' in _content_lower or 'error:' in _content_lower or 'exception:' in _content_lower or 'traceback' in _content_lower or 'command not found' in _content_lower or 'invalid syntax' in _content_lower or 'failed to' in _content_lower) %}
-            {%- set ns2.consecutive_failures = ns2.consecutive_failures + 1 %}
-        {%- else %}
-            {%- set ns2.consecutive_failures = 0 %}
-        {%- endif %}
-        {%- if ns2.prev_role != 'tool' %}
-            {{- '<|im_start|>user' }}
-        {%- endif %}
-        {%- if max_tool_response_chars > 0 and content | length > max_tool_response_chars %}
-            {%- set content = content[:max_tool_response_chars] + '\n[TRUNCATED — original length ' ~ (content | length | string) ~ ' chars]' %}
-        {%- endif %}
-        {{- '\n<tool_response>\n' + content }}
-        {%- if ns2.consecutive_failures >= 2 %}
-            {{- '\n\n⚠️ SYSTEM WARNING: ' ~ ns2.consecutive_failures ~ ' consecutive tool errors detected. Your previous approach is incorrect. You MUST use a fundamentally different approach or corrected arguments.' }}
-        {%- elif ns2.consecutive_failures == 1 %}
-            {{- '\n\n⚠️ SYSTEM WARNING: The previous tool call returned an error. Diagnose the failure and retry with completely corrected arguments.' }}
-        {%- endif %}
-        {{- '\n</tool_response>' }}
-        {%- if loop.last %}
-            {{- '<|im_end|>\n' }}
-        {%- else %}
-            {%- set _next_role = _msgs[loop.index0 + 1].role %}
-            {%- if _next_role != 'tool' %}
-                {{- '<|im_end|>\n' }}
-            {%- endif %}
-        {%- endif %}
-    {%- else %}
-        {{- '<|im_start|>user\n[' + message.role + ']: ' + content + '<|im_end|>\n' }}
-    {%- endif %}
-    {%- set ns2.prev_role = message.role %}
-{%- endfor %}
-{%- if add_generation_prompt %}
-    {{- '<|im_start|>assistant\n' }}
-    {%- if not ns_state.thinking %}
-        {{- '<think>\n</think>\n' }}
-    {%- elif ns2.consecutive_failures >= 2 %}
-        {{- '<think>\n</think>\n' }}
-    {%- else %}
-        {{- '<think>\n' }}
-    {%- endif %}
-{%- endif %}

archive/v20_chat_template_oneline.txt

@@ -1 +0,0 @@
-{%- set template_version = "qwen3.6-froggeric-v20" %}{%- set image_count = namespace(value=0) %}{%- set video_count = namespace(value=0) %}{%- set add_vision_id = add_vision_id if add_vision_id is defined else false %}{%- set enable_thinking = enable_thinking if enable_thinking is defined else true %}{%- set auto_disable_thinking_with_tools = auto_disable_thinking_with_tools if auto_disable_thinking_with_tools is defined else false %}{%- set _preserve_thinking = preserve_thinking if preserve_thinking is defined else false %}{%- set max_tool_arg_chars = max_tool_arg_chars if max_tool_arg_chars is defined else 0 %}{%- set max_tool_response_chars = max_tool_response_chars if max_tool_response_chars is defined else 0 %}{%- set _has_tools = (tools is defined and tools and tools is iterable and tools is not mapping) %}{%- set ns_state = namespace(thinking=enable_thinking) %}{%- if auto_disable_thinking_with_tools and _has_tools %}{%- set ns_state.thinking = false %}{%- endif %}{%- macro render_content(content, do_vision_count, is_system_content=false) %}{%- if content is string %}{{- content }}{%- elif content is iterable and content is not mapping %}{%- for item in content %}{%- if item is mapping %}{%- if item.type == 'image' or 'image' in item or 'image_url' in item %}{%- if is_system_content %}{{- raise_exception('System message cannot contain images.') }}{%- endif %}{%- if do_vision_count %}{%- set image_count.value = image_count.value + 1 %}{%- endif %}{%- if add_vision_id %}{{- 'Picture ' ~ image_count.value ~ ': ' }}{%- endif %}{{- '<|vision_start|><|image_pad|><|vision_end|>' }}{%- elif item.type == 'video' or 'video' in item %}{%- if is_system_content %}{{- raise_exception('System message cannot contain videos.') }}{%- endif %}{%- if do_vision_count %}{%- set video_count.value = video_count.value + 1 %}{%- endif %}{%- if add_vision_id %}{{- 'Video ' ~ video_count.value ~ ': ' }}{%- endif %}{{- '<|vision_start|><|video_pad|><|vision_end|>' }}{%- elif 'text' in item %}{{- item.text }}{%- else %}{{- raise_exception('Unexpected item type in content.') }}{%- endif %}{%- else %}{{- item | string }}{%- endif %}{%- endfor %}{%- elif content is none or content is undefined %}{{- '' }}{%- else %}{{- raise_exception('Unexpected content type.') }}{%- endif %}{%- endmacro %}{%- if not messages %}{{- raise_exception('No messages provided.') }}{%- endif %}{%- set _first_role = messages[0].role %}{%- if _first_role == 'system' or _first_role == 'developer' %}{%- set _sys_msg = messages[0] %}{%- set _msgs = messages[1:] %}{%- else %}{%- set _sys_msg = none %}{%- set _msgs = messages %}{%- endif %}{%- set _sc = '' %}{%- if _sys_msg is not none %}{%- set _sc = render_content(_sys_msg.content, false, true) | trim %}{%- if '<|think_off|>' in _sc %}{%- set ns_state.thinking = false %}{%- set _sc = _sc.split('<|think_off|>') | join('') | trim %}{%- elif '<|think_on|>' in _sc %}{%- set ns_state.thinking = true %}{%- set _sc = _sc.split('<|think_on|>') | join('') | trim %}{%- endif %}{%- endif %}{%- if _has_tools %}{{- '<|im_start|>system\n' }}{{- '# Tools\n\nYou have access to the following functions:\n\n<tools>' }}{%- for tool in tools %}{{- '\n' }}{{- tool | tojson }}{%- endfor %}{{- '\n</tools>' }}{%- set tool_instructions %} If you choose to call a function ONLY reply in the following format with NO suffix: <think> Brief explanation of tool call </think> <tool_call> <function=example_function_name> <parameter=example_parameter_1> value_1 </parameter> <parameter=example_parameter_2> This is the value for the second parameter that can span multiple lines </parameter> </function> </tool_call> <IMPORTANT> Reminder: - You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user. - ALL explanation and reasoning MUST be placed strictly inside the <think></think> block. - Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags. - If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after closing </think>. Do NOT output any conversational text before the tool call. - The <tool_call> and <function> tags MUST be at the very beginning of a new line, with NO spaces or indentation before them. - To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks. - If you have gathered all necessary data and do not need to call a tool, answer the question like normal and provide your final response to the user IMMEDIATELY after closing </think>. </IMPORTANT> {%- endset %}{{- '\n\n' ~ tool_instructions | trim }}{%- if _sc %}{{- '\n\n' + _sc }}{%- endif %}{{- '<|im_end|>\n' }}{%- else %}{%- if _sc %}{{- '<|im_start|>system\n' + _sc + '<|im_end|>\n' }}{%- endif %}{%- endif %}{%- set _last_idx = _msgs | length - 1 %}{%- set ns = namespace(multi_step_tool=true, last_query_index=_last_idx) %}{%- for message in _msgs[::-1] %}{%- set index = (_msgs | length - 1) - loop.index0 %}{%- if ns.multi_step_tool and message.role == 'user' %}{%- set _rc = render_content(message.content, false) | trim %}{%- if not (_rc.startswith('<tool_response>') and _rc.endswith('</tool_response>')) %}{%- set ns.multi_step_tool = false %}{%- set ns.last_query_index = index %}{%- endif %}{%- endif %}{%- endfor %}{%- if ns.multi_step_tool %}{%- if _last_idx > 50 %}{%- set ns.last_query_index = _last_idx %}{%- else %}{%- set ns.last_query_index = 0 %}{%- endif %}{%- endif %}{%- set ns2 = namespace(prev_role='', consecutive_failures=0) %}{%- for message in _msgs %}{%- set is_system = (message.role == "system" or message.role == "developer") %}{%- set content = render_content(message.content, true, is_system) | trim %}{%- if '<|think_off|>' in content %}{%- set ns_state.thinking = false %}{%- set content = content.split('<|think_off|>') | join('') | trim %}{%- elif '<|think_on|>' in content %}{%- set ns_state.thinking = true %}{%- set content = content.split('<|think_on|>') | join('') | trim %}{%- endif %}{%- if is_system %}{{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}{%- elif message.role == 'user' %}{%- set ns2.consecutive_failures = 0 %}{{- '<|im_start|>user\n' + content + '<|im_end|>\n' }}{%- elif message.role == 'assistant' %}{%- set reasoning_content = '' %}{%- if message.reasoning_content is defined and message.reasoning_content is not none %}{%- if message.reasoning_content is string %}{%- set reasoning_content = message.reasoning_content %}{%- else %}{%- set reasoning_content = message.reasoning_content | string %}{%- endif %}{%- else %}{%- set _think_end = '' %}{%- if '</think>' in content %}{%- set _think_end = '</think>' %}{%- elif '</thinking>' in content %}{%- set _think_end = '</thinking>' %}{%- elif '</ think>' in content %}{%- set _think_end = '</ think>' %}{%- elif '</think >' in content %}{%- set _think_end = '</think >' %}{%- endif %}{%- if _think_end %}{%- if _think_end == '</thinking>' %}{%- set _think_start = '<thinking>' %}{%- else %}{%- set _think_start = '<think>' %}{%- endif %}{%- set reasoning_content = content.split(_think_end)[0].rstrip('\n') %}{%- if _think_start in reasoning_content %}{%- set reasoning_content = reasoning_content.split(_think_start)[-1].lstrip('\n') %}{%- endif %}{%- set content = content.split(_think_end)[-1].lstrip('\n') %}{%- endif %}{%- endif %}{%- set reasoning_content = reasoning_content | trim %}{%- if (_preserve_thinking or loop.index0 > ns.last_query_index) and reasoning_content %}{{- '<|im_start|>assistant\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}{%- else %}{{- '<|im_start|>assistant\n' + content }}{%- endif %}{%- if message.tool_calls is defined and message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}{%- for tool_call in message.tool_calls %}{%- if tool_call.function is defined and tool_call.function is not none %}{%- set tc = tool_call.function %}{%- else %}{%- set tc = tool_call %}{%- endif %}{%- if loop.first %}{%- if content | trim %}{{- '\n\n<tool_call>\n<function=' + tc.name + '>\n' }}{%- else %}{{- '<tool_call>\n<function=' + tc.name + '>\n' }}{%- endif %}{%- else %}{{- '\n\n<tool_call>\n<function=' + tc.name + '>\n' }}{%- endif %}{%- if tc.arguments is defined and tc.arguments is not none %}{%- if tc.arguments is mapping %}{%- for args_name, args_value in tc.arguments.items() %}{{- '<parameter=' + args_name + '>\n' }}{%- if args_value is mapping or (args_value is sequence and args_value is not string) %}{%- set _av = args_value | tojson %}{%- else %}{%- set _av = args_value | string %}{%- endif %}{%- if max_tool_arg_chars > 0 and _av | length > max_tool_arg_chars %}{{- _av[:max_tool_arg_chars] + '\n[TRUNCATED — original length ' ~ (_av | length | string) ~ ' chars]' }}{%- else %}{{- _av }}{%- endif %}{{- '\n</parameter>\n' }}{%- endfor %}{%- elif tc.arguments is string and tc.arguments %}{{- tc.arguments }}{%- endif %}{%- endif %}{%- if loop.last %}{{- '</function>\n</tool_call>\n' }}{%- else %}{{- '</function>\n</tool_call>' }}{%- endif %}{%- endfor %}{%- endif %}{{- '<|im_end|>\n' }}{%- elif message.role == 'tool' %}{%- set _content_lower = content | lower %}{%- if content | length < 500 and '$ ' not in content and 'took ' not in _content_lower and ('"error":' in _content_lower or 'error:' in _content_lower or 'exception:' in _content_lower or 'traceback' in _content_lower or 'command not found' in _content_lower or 'invalid syntax' in _content_lower or 'failed to' in _content_lower) %}{%- set ns2.consecutive_failures = ns2.consecutive_failures + 1 %}{%- else %}{%- set ns2.consecutive_failures = 0 %}{%- endif %}{%- if ns2.prev_role != 'tool' %}{{- '<|im_start|>user' }}{%- endif %}{%- if max_tool_response_chars > 0 and content | length > max_tool_response_chars %}{%- set content = content[:max_tool_response_chars] + '\n[TRUNCATED — original length ' ~ (content | length | string) ~ ' chars]' %}{%- endif %}{{- '\n<tool_response>\n' + content }}{%- if ns2.consecutive_failures >= 2 %}{{- '\n\n⚠️ SYSTEM WARNING: ' ~ ns2.consecutive_failures ~ ' consecutive tool errors detected. Your previous approach is incorrect. You MUST use a fundamentally different approach or corrected arguments.' }}{%- elif ns2.consecutive_failures == 1 %}{{- '\n\n⚠️ SYSTEM WARNING: The previous tool call returned an error. Diagnose the failure and retry with completely corrected arguments.' }}{%- endif %}{{- '\n</tool_response>' }}{%- if loop.last %}{{- '<|im_end|>\n' }}{%- else %}{%- set _next_role = _msgs[loop.index0 + 1].role %}{%- if _next_role != 'tool' %}{{- '<|im_end|>\n' }}{%- endif %}{%- endif %}{%- else %}{{- '<|im_start|>user\n[' + message.role + ']: ' + content + '<|im_end|>\n' }}{%- endif %}{%- set ns2.prev_role = message.role %}{%- endfor %}{%- if add_generation_prompt %}{{- '<|im_start|>assistant\n' }}{%- if not ns_state.thinking %}{{- '<think>\n</think>\n' }}{%- elif ns2.consecutive_failures >= 2 %}{{- '<think>\n</think>\n' }}{%- else %}{{- '<think>\n' }}{%- endif %}{%- endif %}

archive/v21_chat_template.jinja

@@ -1,329 +0,0 @@
-{%- set template_version = "qwen3.6-froggeric-v21.3" %}
-{%- set _tool_format = tool_call_format if tool_call_format is defined else 'xml' %}
-{%- set image_count = namespace(value=0) %}
-{%- set video_count = namespace(value=0) %}
-{%- set add_vision_id = add_vision_id if add_vision_id is defined else false %}
-{%- set enable_thinking = enable_thinking if enable_thinking is defined else true %}
-{%- set auto_disable_thinking_with_tools = auto_disable_thinking_with_tools if auto_disable_thinking_with_tools is defined else false %}
-{%- set _preserve_thinking = preserve_thinking if preserve_thinking is defined else true %}
-{%- set max_tool_arg_chars = max_tool_arg_chars if max_tool_arg_chars is defined else 0 %}
-{%- set max_tool_response_chars = max_tool_response_chars if max_tool_response_chars is defined else 0 %}
-{%- set _has_tools = (tools is defined and tools and tools is iterable and tools is not mapping) %}
-{%- set ns_state = namespace(thinking=enable_thinking) %}
-{%- if auto_disable_thinking_with_tools and _has_tools %}
-    {%- set ns_state.thinking = false %}
-{%- endif %}
-{%- macro render_content(content, do_vision_count, is_system_content=false) %}
-    {%- if content is string %}
-        {{- content }}
-    {%- elif content is iterable and content is not mapping %}
-        {%- for item in content %}
-            {%- if item is mapping %}
-                {%- if item.type == 'image' or 'image' in item or 'image_url' in item %}
-                    {%- if is_system_content %}
-                        {{- raise_exception('System message cannot contain images.') }}
-                    {%- endif %}
-                    {%- if do_vision_count %}
-                        {%- set image_count.value = image_count.value + 1 %}
-                    {%- endif %}
-                    {%- if add_vision_id %}
-                        {{- 'Picture ' ~ image_count.value ~ ': ' }}
-                    {%- endif %}
-                    {{- '<|vision_start|><|image_pad|><|vision_end|>' }}
-                {%- elif item.type == 'video' or 'video' in item %}
-                    {%- if is_system_content %}
-                        {{- raise_exception('System message cannot contain videos.') }}
-                    {%- endif %}
-                    {%- if do_vision_count %}
-                        {%- set video_count.value = video_count.value + 1 %}
-                    {%- endif %}
-                    {%- if add_vision_id %}
-                        {{- 'Video ' ~ video_count.value ~ ': ' }}
-                    {%- endif %}
-                    {{- '<|vision_start|><|video_pad|><|vision_end|>' }}
-                {%- elif 'text' in item %}
-                    {{- item.text }}
-                {%- else %}
-                    {{- raise_exception('Unexpected item type in content.') }}
-                {%- endif %}
-            {%- else %}
-                {{- item | string }}
-            {%- endif %}
-        {%- endfor %}
-    {%- elif content is none or content is undefined %}
-        {{- '' }}
-    {%- else %}
-        {{- raise_exception('Unexpected content type.') }}
-    {%- endif %}
-{%- endmacro %}
-{%- if not messages %}
-    {{- raise_exception('No messages provided.') }}
-{%- endif %}
-{%- set _first_role = messages[0].role %}
-{%- if _first_role == 'system' or _first_role == 'developer' %}
-    {%- set _sys_msg = messages[0] %}
-    {%- set _msgs = messages[1:] %}
-{%- else %}
-    {%- set _sys_msg = none %}
-    {%- set _msgs = messages %}
-{%- endif %}
-{%- set _sc = '' %}
-{%- if _sys_msg is not none %}
-    {%- set _sc = render_content(_sys_msg.content, false, true) | trim %}
-    {%- if '<|think_off|>' in _sc %}
-        {%- set ns_state.thinking = false %}
-        {%- set _sc = _sc.split('<|think_off|>') | join('') | trim %}
-    {%- elif '<|think_on|>' in _sc %}
-        {%- set ns_state.thinking = true %}
-        {%- set _sc = _sc.split('<|think_on|>') | join('') | trim %}
-    {%- endif %}
-{%- endif %}
-{%- if _has_tools %}
-    {{- '<|im_start|>system\n' }}
-    {{- '# Tools\n\nYou have access to the following functions:\n\n<tools>' }}
-    {%- for tool in tools %}
-        {{- '\n' }}
-        {{- tool | tojson }}
-    {%- endfor %}
-    {{- '\n</tools>' }}
-    {%- set tool_instructions %}
-If you choose to call a function ONLY reply in the following format with NO suffix:
-
-{%- if _tool_format == 'json' %}
-<think>
-Brief explanation of tool call
-</think>
-<tool_call>
-{"name": "example_function_name", "arguments": {"example_parameter_1": "value_1", "example_parameter_2": "This is the value for the second parameter"}}
-</tool_call>
-{%- else %}
-<think>
-Brief explanation of tool call
-</think>
-<tool_call>
-<function=example_function_name>
-<parameter=example_parameter_1>
-value_1
-</parameter>
-<parameter=example_parameter_2>
-This is the value for the second parameter
-that can span
-multiple lines
-</parameter>
-</function>
-</tool_call>
-{%- endif %}
-
-<IMPORTANT>
-Reminder:
-- You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user.
-- ALL explanation and reasoning MUST be placed strictly inside the <think></think> block.
-{%- if _tool_format == 'json' %}
-- Function calls MUST follow the specified format: a single JSON object with "name" and "arguments" keys inside <tool_call></tool_call> XML tags.
-{%- else %}
-- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags.
-{%- endif %}
-- If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after thinking, with NO conversational text before it.
-{%- if _tool_format == 'json' %}
-- The <tool_call> tag MUST be at the very beginning of a new line, with NO spaces or indentation before it.
-{%- else %}
-- The <tool_call> and <function> tags MUST be at the very beginning of a new line, with NO spaces or indentation before them.
-{%- endif %}
-- To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks.
-- If you have all necessary data, provide your final answer directly to the user without any tool call.
-</IMPORTANT>
-    {%- endset %}
-    {{- '\n\n' ~ tool_instructions | trim }}
-    {%- if _sc %}
-        {{- '\n\n' + _sc }}
-    {%- endif %}
-    {{- '<|im_end|>\n' }}
-{%- else %}
-    {%- if _sc %}
-        {{- '<|im_start|>system\n' + _sc + '<|im_end|>\n' }}
-    {%- endif %}
-{%- endif %}
-{%- set _last_idx = _msgs | length - 1 %}
-{%- set ns = namespace(multi_step_tool=true, last_query_index=_last_idx) %}
-{%- for message in _msgs[::-1] %}
-    {%- set index = (_msgs | length - 1) - loop.index0 %}
-    {%- if ns.multi_step_tool and message.role == 'user' %}
-        {%- set _rc = render_content(message.content, false) | trim %}
-        {%- if not (_rc.startswith('<tool_response>') and _rc.endswith('</tool_response>')) %}
-            {%- set ns.multi_step_tool = false %}
-            {%- set ns.last_query_index = index %}
-        {%- endif %}
-    {%- endif %}
-{%- endfor %}
-{%- if ns.multi_step_tool %}
-    {%- if _last_idx > 50 %}
-        {%- set ns.last_query_index = _last_idx %}
-    {%- else %}
-        {%- set ns.last_query_index = 0 %}
-    {%- endif %}
-{%- endif %}
-{%- set ns2 = namespace(prev_role='', consecutive_failures=0) %}
-{%- for message in _msgs %}
-    {%- set is_system = (message.role == "system" or message.role == "developer") %}
-    {%- set content = render_content(message.content, true, is_system) | trim %}
-    {%- if is_system or message.role == 'user' %}
-        {%- if '<|think_off|>' in content %}
-            {%- set ns_state.thinking = false %}
-            {%- set content = content.split('<|think_off|>') | join('') | trim %}
-        {%- elif '<|think_on|>' in content %}
-            {%- set ns_state.thinking = true %}
-            {%- set content = content.split('<|think_on|>') | join('') | trim %}
-        {%- endif %}
-    {%- endif %}
-    {%- if is_system %}
-        {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}
-    {%- elif message.role == 'user' %}
-        {%- set ns2.consecutive_failures = 0 %}
-        {{- '<|im_start|>user\n' + content + '<|im_end|>\n' }}
-    {%- elif message.role == 'assistant' %}
-        {%- set reasoning_content = '' %}
-        {%- if message.reasoning_content is defined and message.reasoning_content is not none %}
-            {%- if message.reasoning_content is string %}
-                {%- set reasoning_content = message.reasoning_content %}
-            {%- else %}
-                {%- set reasoning_content = message.reasoning_content | string %}
-            {%- endif %}
-        {%- elif message.thinking is defined and message.thinking is not none %}
-            {%- if message.thinking is string %}
-                {%- set reasoning_content = message.thinking %}
-            {%- else %}
-                {%- set reasoning_content = message.thinking | string %}
-            {%- endif %}
-        {%- else %}
-            {%- set _think_end = '' %}
-            {%- if content.startswith('</think>') %}
-                {%- set _think_end = '</think>' %}
-            {%- elif content.startswith('</thinking>') %}
-                {%- set _think_end = '</thinking>' %}
-            {%- elif '\n</think>' in content %}
-                {%- set _think_end = '\n</think>' %}
-            {%- elif '\n</thinking>' in content %}
-                {%- set _think_end = '\n</thinking>' %}
-            {%- elif '\n</ think>' in content %}
-                {%- set _think_end = '\n</ think>' %}
-            {%- elif '\n</think >' in content %}
-                {%- set _think_end = '\n</think >' %}
-            {%- endif %}
-            {%- if _think_end %}
-                {%- if 'thinking' in _think_end %}
-                    {%- set _think_start = '<thinking>' %}
-                {%- else %}
-                    {%- set _think_start = '<think>' %}
-                {%- endif %}
-                {%- set reasoning_content = content.split(_think_end)[0].rstrip('\n') %}
-                {%- if _think_start in reasoning_content %}
-                    {%- set reasoning_content = reasoning_content.split(_think_start)[-1].lstrip('\n') %}
-                {%- endif %}
-                {%- set content = content.split(_think_end)[-1].lstrip('\n') %}
-            {%- endif %}
-        {%- endif %}
-        {%- set reasoning_content = reasoning_content | trim %}
-        {%- if (_preserve_thinking or loop.index0 > ns.last_query_index) and reasoning_content %}
-            {{- '<|im_start|>assistant\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}
-        {%- else %}
-            {{- '<|im_start|>assistant\n' + content }}
-        {%- endif %}
-        {%- if message.tool_calls is defined and message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}
-            {%- for tool_call in message.tool_calls %}
-                {%- if tool_call.function is defined and tool_call.function is not none %}
-                    {%- set tc = tool_call.function %}
-                {%- else %}
-                    {%- set tc = tool_call %}
-                {%- endif %}
-                {%- if _tool_format == 'json' %}
-                    {%- if not loop.first or content | trim %}
-                        {{- '\n\n' }}
-                    {%- endif %}
-                    {%- set _args = '{}' %}
-                    {%- if tc.arguments is defined and tc.arguments is not none %}
-                        {%- if tc.arguments is mapping %}
-                            {%- set _args = tc.arguments | tojson %}
-                        {%- elif tc.arguments is string and tc.arguments %}
-                            {%- set _args = tc.arguments %}
-                        {%- endif %}
-                    {%- endif %}
-                    {{- '<tool_call>\n{"name": ' }}{{- tc.name | tojson }}{{- ', "arguments": ' }}{{- _args }}{{- '}\n</tool_call>' }}
-                {%- else %}
-                    {%- if loop.first %}
-                        {%- if content | trim %}
-                            {{- '\n\n<tool_call>\n<function=' + tc.name + '>\n' }}
-                        {%- else %}
-                            {{- '<tool_call>\n<function=' + tc.name + '>\n' }}
-                        {%- endif %}
-                    {%- else %}
-                        {{- '\n\n<tool_call>\n<function=' + tc.name + '>\n' }}
-                    {%- endif %}
-                    {%- if tc.arguments is defined and tc.arguments is not none %}
-                        {%- if tc.arguments is mapping %}
-                            {%- for args_name, args_value in tc.arguments.items() %}
-                                {{- '<parameter=' + args_name + '>\n' }}
-                                {%- if args_value is mapping or (args_value is sequence and args_value is not string) %}
-                                    {%- set _av = args_value | tojson %}
-                                {%- else %}
-                                    {%- set _av = args_value | string %}
-                                {%- endif %}
-                                {%- if max_tool_arg_chars > 0 and _av | length > max_tool_arg_chars %}
-                                    {{- _av[:max_tool_arg_chars] + '\n[TRUNCATED — original length ' ~ (_av | length | string) ~ ' chars]' }}
-                                {%- else %}
-                                    {{- _av }}
-                                {%- endif %}
-                                {{- '\n</parameter>\n' }}
-                            {%- endfor %}
-                        {%- elif tc.arguments is string and tc.arguments %}
-                            {{- tc.arguments }}
-                        {%- endif %}
-                    {%- endif %}
-                    {{- '</function>\n</tool_call>' }}
-                {%- endif %}
-            {%- endfor %}
-        {%- endif %}
-        {{- '<|im_end|>\n' }}
-    {%- elif message.role == 'tool' %}
-        {%- set _content_lower = content | lower %}
-        {%- set _content_head = _content_lower[:80] %}
-        {%- if content | length < 500 and '$ ' not in content and 'took ' not in _content_lower and ('"error":' in _content_head or 'error:' in _content_head or 'err!' in _content_head or 'fatal:' in _content_head or 'exception:' in _content_head or 'traceback' in _content_head or 'command not found' in _content_head or 'invalid syntax' in _content_head or 'failed to' in _content_head) %}
-            {%- set ns2.consecutive_failures = ns2.consecutive_failures + 1 %}
-        {%- else %}
-            {%- set ns2.consecutive_failures = 0 %}
-        {%- endif %}
-        {%- if ns2.prev_role != 'tool' %}
-            {{- '<|im_start|>user' }}
-        {%- endif %}
-        {%- if max_tool_response_chars > 0 and content | length > max_tool_response_chars %}
-            {%- set content = content[:max_tool_response_chars] + '\n[TRUNCATED — original length ' ~ (content | length | string) ~ ' chars]' %}
-        {%- endif %}
-        {{- '\n<tool_response>\n' + content }}
-        {%- if ns2.consecutive_failures >= 2 %}
-            {{- '\n\n⚠️ SYSTEM WARNING: ' ~ ns2.consecutive_failures ~ ' consecutive tool errors detected. Your previous approach is incorrect. You MUST use a fundamentally different approach or corrected arguments.' }}
-        {%- elif ns2.consecutive_failures == 1 %}
-            {{- '\n\n⚠️ SYSTEM WARNING: The previous tool call returned an error. Diagnose the failure and retry with completely corrected arguments.' }}
-        {%- endif %}
-        {{- '\n</tool_response>' }}
-        {%- if loop.last %}
-            {{- '<|im_end|>\n' }}
-        {%- else %}
-            {%- set _next_role = _msgs[loop.index0 + 1].role %}
-            {%- if _next_role != 'tool' %}
-                {{- '<|im_end|>\n' }}
-            {%- endif %}
-        {%- endif %}
-    {%- else %}
-        {{- '<|im_start|>user\n[' + message.role + ']: ' + content + '<|im_end|>\n' }}
-    {%- endif %}
-    {%- set ns2.prev_role = message.role %}
-{%- endfor %}
-{%- if add_generation_prompt %}
-    {{- '<|im_start|>assistant\n' }}
-    {%- if not ns_state.thinking %}
-        {{- '<think>\n\n</think>\n\n' }}
-    {%- elif ns2.consecutive_failures >= 2 %}
-        {{- '<think>\n\n</think>\n\n' }}
-    {%- else %}
-        {{- '<think>\n' }}
-    {%- endif %}
-{%- endif %}

archive/v21_chat_template_oneline.txt

@@ -1 +0,0 @@
-{%- set template_version = "qwen3.6-froggeric-v21.3" %}{%- set _tool_format = tool_call_format if tool_call_format is defined else 'xml' %}{%- set image_count = namespace(value=0) %}{%- set video_count = namespace(value=0) %}{%- set add_vision_id = add_vision_id if add_vision_id is defined else false %}{%- set enable_thinking = enable_thinking if enable_thinking is defined else true %}{%- set auto_disable_thinking_with_tools = auto_disable_thinking_with_tools if auto_disable_thinking_with_tools is defined else false %}{%- set _preserve_thinking = preserve_thinking if preserve_thinking is defined else true %}{%- set max_tool_arg_chars = max_tool_arg_chars if max_tool_arg_chars is defined else 0 %}{%- set max_tool_response_chars = max_tool_response_chars if max_tool_response_chars is defined else 0 %}{%- set _has_tools = (tools is defined and tools and tools is iterable and tools is not mapping) %}{%- set ns_state = namespace(thinking=enable_thinking) %}{%- if auto_disable_thinking_with_tools and _has_tools %}    {%- set ns_state.thinking = false %}{%- endif %}{%- macro render_content(content, do_vision_count, is_system_content=false) %}    {%- if content is string %}        {{- content }}    {%- elif content is iterable and content is not mapping %}        {%- for item in content %}            {%- if item is mapping %}                {%- if item.type == 'image' or 'image' in item or 'image_url' in item %}                    {%- if is_system_content %}                        {{- raise_exception('System message cannot contain images.') }}                    {%- endif %}                    {%- if do_vision_count %}                        {%- set image_count.value = image_count.value + 1 %}                    {%- endif %}                    {%- if add_vision_id %}                        {{- 'Picture ' ~ image_count.value ~ ': ' }}                    {%- endif %}                    {{- '<|vision_start|><|image_pad|><|vision_end|>' }}                {%- elif item.type == 'video' or 'video' in item %}                    {%- if is_system_content %}                        {{- raise_exception('System message cannot contain videos.') }}                    {%- endif %}                    {%- if do_vision_count %}                        {%- set video_count.value = video_count.value + 1 %}                    {%- endif %}                    {%- if add_vision_id %}                        {{- 'Video ' ~ video_count.value ~ ': ' }}                    {%- endif %}                    {{- '<|vision_start|><|video_pad|><|vision_end|>' }}                {%- elif 'text' in item %}                    {{- item.text }}                {%- else %}                    {{- raise_exception('Unexpected item type in content.') }}                {%- endif %}            {%- else %}                {{- item | string }}            {%- endif %}        {%- endfor %}    {%- elif content is none or content is undefined %}        {{- '' }}    {%- else %}        {{- raise_exception('Unexpected content type.') }}    {%- endif %}{%- endmacro %}{%- if not messages %}    {{- raise_exception('No messages provided.') }}{%- endif %}{%- set _first_role = messages[0].role %}{%- if _first_role == 'system' or _first_role == 'developer' %}    {%- set _sys_msg = messages[0] %}    {%- set _msgs = messages[1:] %}{%- else %}    {%- set _sys_msg = none %}    {%- set _msgs = messages %}{%- endif %}{%- set _sc = '' %}{%- if _sys_msg is not none %}    {%- set _sc = render_content(_sys_msg.content, false, true) | trim %}    {%- if '<|think_off|>' in _sc %}        {%- set ns_state.thinking = false %}        {%- set _sc = _sc.split('<|think_off|>') | join('') | trim %}    {%- elif '<|think_on|>' in _sc %}        {%- set ns_state.thinking = true %}        {%- set _sc = _sc.split('<|think_on|>') | join('') | trim %}    {%- endif %}{%- endif %}{%- if _has_tools %}    {{- '<|im_start|>system\n' }}    {{- '# Tools\n\nYou have access to the following functions:\n\n<tools>' }}    {%- for tool in tools %}        {{- '\n' }}        {{- tool | tojson }}    {%- endfor %}    {{- '\n</tools>' }}    {%- set tool_instructions %}If you choose to call a function ONLY reply in the following format with NO suffix:{%- if _tool_format == 'json' %}<think>Brief explanation of tool call</think><tool_call>{"name": "example_function_name", "arguments": {"example_parameter_1": "value_1", "example_parameter_2": "This is the value for the second parameter"}}</tool_call>{%- else %}<think>Brief explanation of tool call</think><tool_call><function=example_function_name><parameter=example_parameter_1>value_1</parameter><parameter=example_parameter_2>This is the value for the second parameterthat can spanmultiple lines</parameter></function></tool_call>{%- endif %}<IMPORTANT>Reminder:- You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user.- ALL explanation and reasoning MUST be placed strictly inside the <think></think> block.{%- if _tool_format == 'json' %}- Function calls MUST follow the specified format: a single JSON object with "name" and "arguments" keys inside <tool_call></tool_call> XML tags.{%- else %}- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags.{%- endif %}- If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after thinking, with NO conversational text before it.{%- if _tool_format == 'json' %}- The <tool_call> tag MUST be at the very beginning of a new line, with NO spaces or indentation before it.{%- else %}- The <tool_call> and <function> tags MUST be at the very beginning of a new line, with NO spaces or indentation before them.{%- endif %}- To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks.- If you have all necessary data, provide your final answer directly to the user without any tool call.</IMPORTANT>    {%- endset %}    {{- '\n\n' ~ tool_instructions | trim }}    {%- if _sc %}        {{- '\n\n' + _sc }}    {%- endif %}    {{- '<|im_end|>\n' }}{%- else %}    {%- if _sc %}        {{- '<|im_start|>system\n' + _sc + '<|im_end|>\n' }}    {%- endif %}{%- endif %}{%- set _last_idx = _msgs | length - 1 %}{%- set ns = namespace(multi_step_tool=true, last_query_index=_last_idx) %}{%- for message in _msgs[::-1] %}    {%- set index = (_msgs | length - 1) - loop.index0 %}    {%- if ns.multi_step_tool and message.role == 'user' %}        {%- set _rc = render_content(message.content, false) | trim %}        {%- if not (_rc.startswith('<tool_response>') and _rc.endswith('</tool_response>')) %}            {%- set ns.multi_step_tool = false %}            {%- set ns.last_query_index = index %}        {%- endif %}    {%- endif %}{%- endfor %}{%- if ns.multi_step_tool %}    {%- if _last_idx > 50 %}        {%- set ns.last_query_index = _last_idx %}    {%- else %}        {%- set ns.last_query_index = 0 %}    {%- endif %}{%- endif %}{%- set ns2 = namespace(prev_role='', consecutive_failures=0) %}{%- for message in _msgs %}    {%- set is_system = (message.role == "system" or message.role == "developer") %}    {%- set content = render_content(message.content, true, is_system) | trim %}    {%- if is_system or message.role == 'user' %}        {%- if '<|think_off|>' in content %}            {%- set ns_state.thinking = false %}            {%- set content = content.split('<|think_off|>') | join('') | trim %}        {%- elif '<|think_on|>' in content %}            {%- set ns_state.thinking = true %}            {%- set content = content.split('<|think_on|>') | join('') | trim %}        {%- endif %}    {%- endif %}    {%- if is_system %}        {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}    {%- elif message.role == 'user' %}        {%- set ns2.consecutive_failures = 0 %}        {{- '<|im_start|>user\n' + content + '<|im_end|>\n' }}    {%- elif message.role == 'assistant' %}        {%- set reasoning_content = '' %}        {%- if message.reasoning_content is defined and message.reasoning_content is not none %}            {%- if message.reasoning_content is string %}                {%- set reasoning_content = message.reasoning_content %}            {%- else %}                {%- set reasoning_content = message.reasoning_content | string %}            {%- endif %}        {%- elif message.thinking is defined and message.thinking is not none %}            {%- if message.thinking is string %}                {%- set reasoning_content = message.thinking %}            {%- else %}                {%- set reasoning_content = message.thinking | string %}            {%- endif %}        {%- else %}            {%- set _think_end = '' %}            {%- if content.startswith('</think>') %}                {%- set _think_end = '</think>' %}            {%- elif content.startswith('</thinking>') %}                {%- set _think_end = '</thinking>' %}            {%- elif '\n</think>' in content %}                {%- set _think_end = '\n</think>' %}            {%- elif '\n</thinking>' in content %}                {%- set _think_end = '\n</thinking>' %}            {%- elif '\n</ think>' in content %}                {%- set _think_end = '\n</ think>' %}            {%- elif '\n</think >' in content %}                {%- set _think_end = '\n</think >' %}            {%- endif %}            {%- if _think_end %}                {%- if 'thinking' in _think_end %}                    {%- set _think_start = '<thinking>' %}                {%- else %}                    {%- set _think_start = '<think>' %}                {%- endif %}                {%- set reasoning_content = content.split(_think_end)[0].rstrip('\n') %}                {%- if _think_start in reasoning_content %}                    {%- set reasoning_content = reasoning_content.split(_think_start)[-1].lstrip('\n') %}                {%- endif %}                {%- set content = content.split(_think_end)[-1].lstrip('\n') %}            {%- endif %}        {%- endif %}        {%- set reasoning_content = reasoning_content | trim %}        {%- if (_preserve_thinking or loop.index0 > ns.last_query_index) and reasoning_content %}            {{- '<|im_start|>assistant\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}        {%- else %}            {{- '<|im_start|>assistant\n' + content }}        {%- endif %}        {%- if message.tool_calls is defined and message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}            {%- for tool_call in message.tool_calls %}                {%- if tool_call.function is defined and tool_call.function is not none %}                    {%- set tc = tool_call.function %}                {%- else %}                    {%- set tc = tool_call %}                {%- endif %}                {%- if _tool_format == 'json' %}                    {%- if not loop.first or content | trim %}                        {{- '\n\n' }}                    {%- endif %}                    {%- set _args = '{}' %}                    {%- if tc.arguments is defined and tc.arguments is not none %}                        {%- if tc.arguments is mapping %}                            {%- set _args = tc.arguments | tojson %}                        {%- elif tc.arguments is string and tc.arguments %}                            {%- set _args = tc.arguments %}                        {%- endif %}                    {%- endif %}                    {{- '<tool_call>\n{"name": ' }}{{- tc.name | tojson }}{{- ', "arguments": ' }}{{- _args }}{{- '}\n</tool_call>' }}                {%- else %}                    {%- if loop.first %}                        {%- if content | trim %}                            {{- '\n\n<tool_call>\n<function=' + tc.name + '>\n' }}                        {%- else %}                            {{- '<tool_call>\n<function=' + tc.name + '>\n' }}                        {%- endif %}                    {%- else %}                        {{- '\n\n<tool_call>\n<function=' + tc.name + '>\n' }}                    {%- endif %}                    {%- if tc.arguments is defined and tc.arguments is not none %}                        {%- if tc.arguments is mapping %}                            {%- for args_name, args_value in tc.arguments.items() %}                                {{- '<parameter=' + args_name + '>\n' }}                                {%- if args_value is mapping or (args_value is sequence and args_value is not string) %}                                    {%- set _av = args_value | tojson %}                                {%- else %}                                    {%- set _av = args_value | string %}                                {%- endif %}                                {%- if max_tool_arg_chars > 0 and _av | length > max_tool_arg_chars %}                                    {{- _av[:max_tool_arg_chars] + '\n[TRUNCATED — original length ' ~ (_av | length | string) ~ ' chars]' }}                                {%- else %}                                    {{- _av }}                                {%- endif %}                                {{- '\n</parameter>\n' }}                            {%- endfor %}                        {%- elif tc.arguments is string and tc.arguments %}                            {{- tc.arguments }}                        {%- endif %}                    {%- endif %}                    {{- '</function>\n</tool_call>' }}                {%- endif %}            {%- endfor %}        {%- endif %}        {{- '<|im_end|>\n' }}    {%- elif message.role == 'tool' %}        {%- set _content_lower = content | lower %}        {%- set _content_head = _content_lower[:80] %}        {%- if content | length < 500 and '$ ' not in content and 'took ' not in _content_lower and ('"error":' in _content_head or 'error:' in _content_head or 'err!' in _content_head or 'fatal:' in _content_head or 'exception:' in _content_head or 'traceback' in _content_head or 'command not found' in _content_head or 'invalid syntax' in _content_head or 'failed to' in _content_head) %}            {%- set ns2.consecutive_failures = ns2.consecutive_failures + 1 %}        {%- else %}            {%- set ns2.consecutive_failures = 0 %}        {%- endif %}        {%- if ns2.prev_role != 'tool' %}            {{- '<|im_start|>user' }}        {%- endif %}        {%- if max_tool_response_chars > 0 and content | length > max_tool_response_chars %}            {%- set content = content[:max_tool_response_chars] + '\n[TRUNCATED — original length ' ~ (content | length | string) ~ ' chars]' %}        {%- endif %}        {{- '\n<tool_response>\n' + content }}        {%- if ns2.consecutive_failures >= 2 %}            {{- '\n\n⚠️ SYSTEM WARNING: ' ~ ns2.consecutive_failures ~ ' consecutive tool errors detected. Your previous approach is incorrect. You MUST use a fundamentally different approach or corrected arguments.' }}        {%- elif ns2.consecutive_failures == 1 %}            {{- '\n\n⚠️ SYSTEM WARNING: The previous tool call returned an error. Diagnose the failure and retry with completely corrected arguments.' }}        {%- endif %}        {{- '\n</tool_response>' }}        {%- if loop.last %}            {{- '<|im_end|>\n' }}        {%- else %}            {%- set _next_role = _msgs[loop.index0 + 1].role %}            {%- if _next_role != 'tool' %}                {{- '<|im_end|>\n' }}            {%- endif %}        {%- endif %}    {%- else %}        {{- '<|im_start|>user\n[' + message.role + ']: ' + content + '<|im_end|>\n' }}    {%- endif %}    {%- set ns2.prev_role = message.role %}{%- endfor %}{%- if add_generation_prompt %}    {{- '<|im_start|>assistant\n' }}    {%- if not ns_state.thinking %}        {{- '<think>\n\n</think>\n\n' }}    {%- elif ns2.consecutive_failures >= 2 %}        {{- '<think>\n\n</think>\n\n' }}    {%- else %}        {{- '<think>\n' }}    {%- endif %}{%- endif %}

archive/v22.1_chat_template.jinja

@@ -1,363 +0,0 @@
-{%- set template_version = "qwen3.8-froggeric-v22.1" %}
-{%- set _tool_format = tool_call_format if tool_call_format is defined else 'xml' %}
-{%- set image_count = namespace(value=0) %}
-{%- set video_count = namespace(value=0) %}
-{%- set add_vision_id = add_vision_id if add_vision_id is defined else false %}
-{%- set enable_thinking = enable_thinking if enable_thinking is defined else true %}
-{%- set auto_disable_thinking_with_tools = auto_disable_thinking_with_tools if auto_disable_thinking_with_tools is defined else false %}
-{%- if preserve_reasoning is defined and preserve_reasoning is not none %}
-    {%- set _preserve_thinking = preserve_reasoning %}
-{%- elif preserve_thinking is defined and preserve_thinking is not none %}
-    {%- set _preserve_thinking = preserve_thinking %}
-{%- else %}
-    {%- set _preserve_thinking = true %}
-{%- endif %}
-{%- set max_tool_arg_chars = max_tool_arg_chars if max_tool_arg_chars is defined else 0 %}
-{%- set max_tool_response_chars = max_tool_response_chars if max_tool_response_chars is defined else 0 %}
-{%- set _has_tools = (tools is defined and tools and tools is iterable and tools is not mapping) %}
-{%- set _effort_raw = (reasoning_effort | string | lower) if reasoning_effort is defined and reasoning_effort is not none else 'medium' %}
-{%- set _initial_thinking = enable_thinking %}
-{%- set _initial_effort = 'medium' %}
-{%- if _effort_raw == 'none' %}
-    {%- set _initial_thinking = false %}
-    {%- set _initial_effort = 'medium' %}
-{%- elif _effort_raw == 'minimal' or _effort_raw == 'low' %}
-    {%- set _initial_effort = 'low' %}
-{%- elif _effort_raw == 'high' or _effort_raw == 'xhigh' or _effort_raw == 'max' %}
-    {%- set _initial_effort = 'xhigh' %}
-{%- else %}
-    {%- set _initial_effort = 'medium' %}
-{%- endif %}
-{%- set ns_state = namespace(thinking=_initial_thinking, effort=_initial_effort) %}
-{%- if auto_disable_thinking_with_tools and _has_tools %}
-    {%- set ns_state.thinking = false %}
-{%- endif %}
-{%- for msg in messages %}
-    {%- if msg.role == 'system' or msg.role == 'developer' or msg.role == 'user' %}
-        {%- if msg.content is string %}
-            {%- if '<|think_off|>' in msg.content %}
-                {%- set ns_state.thinking = false %}
-            {%- elif '<|think_on|>' in msg.content %}
-                {%- set ns_state.thinking = true %}
-            {%- elif '<|think_xhigh|>' in msg.content or '<|think_high|>' in msg.content %}
-                {%- set ns_state.thinking = true %}
-                {%- set ns_state.effort = 'xhigh' %}
-            {%- elif '<|think_low|>' in msg.content or '<|think_minimal|>' in msg.content %}
-                {%- set ns_state.thinking = true %}
-                {%- set ns_state.effort = 'low' %}
-            {%- elif '<|think_medium|>' in msg.content %}
-                {%- set ns_state.thinking = true %}
-                {%- set ns_state.effort = 'medium' %}
-            {%- endif %}
-        {%- elif msg.content is iterable and msg.content is not mapping %}
-            {%- for item in msg.content %}
-                {%- if item is string %}
-                    {%- set _item_text = item %}
-                {%- elif item is mapping and 'text' in item and item.text is string %}
-                    {%- set _item_text = item.text %}
-                {%- else %}
-                    {%- set _item_text = '' %}
-                {%- endif %}
-                {%- if _item_text %}
-                    {%- if '<|think_off|>' in _item_text %}
-                        {%- set ns_state.thinking = false %}
-                    {%- elif '<|think_on|>' in _item_text %}
-                        {%- set ns_state.thinking = true %}
-                    {%- elif '<|think_xhigh|>' in _item_text or '<|think_high|>' in _item_text %}
-                        {%- set ns_state.thinking = true %}
-                        {%- set ns_state.effort = 'xhigh' %}
-                    {%- elif '<|think_low|>' in _item_text or '<|think_minimal|>' in _item_text %}
-                        {%- set ns_state.thinking = true %}
-                        {%- set ns_state.effort = 'low' %}
-                    {%- elif '<|think_medium|>' in _item_text %}
-                        {%- set ns_state.thinking = true %}
-                        {%- set ns_state.effort = 'medium' %}
-                    {%- endif %}
-                {%- endif %}
-            {%- endfor %}
-        {%- endif %}
-    {%- endif %}
-{%- endfor %}
-{%- set reasoning_instructions = '' %}
-{%- if ns_state.thinking %}
-    {%- if ns_state.effort == 'xhigh' %}
-        {%- set reasoning_instructions = 'Reasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.' %}
-    {%- elif ns_state.effort == 'low' %}
-        {%- set reasoning_instructions = 'Reasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration.' %}
-    {%- endif %}
-{%- endif %}
-{%- macro render_content(content, do_vision_count, is_system_content=false) %}
-    {%- if content is string %}
-        {{- content }}
-    {%- elif content is iterable and content is not mapping %}
-        {%- for item in content %}
-            {%- if item is mapping %}
-                {%- if item.type == 'image' or 'image' in item or 'image_url' in item %}
-                    {%- if is_system_content %}
-                        {{- raise_exception('System message cannot contain images.') }}
-                    {%- endif %}
-                    {%- if do_vision_count %}
-                        {%- set image_count.value = image_count.value + 1 %}
-                    {%- endif %}
-                    {%- if add_vision_id %}
-                        {{- 'Picture ' ~ image_count.value ~ ': ' }}
-                    {%- endif %}
-                    {{- '<|vision_start|><|image_pad|><|vision_end|>' }}
-                {%- elif item.type == 'video' or 'video' in item %}
-                    {%- if is_system_content %}
-                        {{- raise_exception('System message cannot contain videos.') }}
-                    {%- endif %}
-                    {%- if do_vision_count %}
-                        {%- set video_count.value = video_count.value + 1 %}
-                    {%- endif %}
-                    {%- if add_vision_id %}
-                        {{- 'Video ' ~ video_count.value ~ ': ' }}
-                    {%- endif %}
-                    {{- '<|vision_start|><|video_pad|><|vision_end|>' }}
-                {%- elif 'text' in item %}
-                    {{- item.text }}
-                {%- else %}
-                    {{- raise_exception('Unexpected item type in content.') }}
-                {%- endif %}
-            {%- else %}
-                {{- item | string }}
-            {%- endif %}
-        {%- endfor %}
-    {%- elif content is none or content is undefined %}
-        {{- '' }}
-    {%- else %}
-        {{- raise_exception('Unexpected content type.') }}
-    {%- endif %}
-{%- endmacro %}
-{%- if not messages %}
-    {{- raise_exception('No messages provided.') }}
-{%- endif %}
-{%- set _first_role = messages[0].role %}
-{%- if _first_role == 'system' or _first_role == 'developer' %}
-    {%- set _sys_msg = messages[0] %}
-    {%- set _msgs = messages[1:] %}
-{%- else %}
-    {%- set _sys_msg = none %}
-    {%- set _msgs = messages %}
-{%- endif %}
-{%- set _sc = '' %}
-{%- if _sys_msg is not none %}
-    {%- set _sc = render_content(_sys_msg.content, false, true) | trim %}
-    {%- if '<|think_off|>' in _sc %}{%- set _sc = _sc.split('<|think_off|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_on|>' in _sc %}{%- set _sc = _sc.split('<|think_on|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_xhigh|>' in _sc %}{%- set _sc = _sc.split('<|think_xhigh|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_high|>' in _sc %}{%- set _sc = _sc.split('<|think_high|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_medium|>' in _sc %}{%- set _sc = _sc.split('<|think_medium|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_low|>' in _sc %}{%- set _sc = _sc.split('<|think_low|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_minimal|>' in _sc %}{%- set _sc = _sc.split('<|think_minimal|>') | join('') | trim %}{%- endif %}
-{%- endif %}
-{%- if _has_tools %}
-    {{- '<|im_start|>system\n' }}
-    {%- if reasoning_instructions %}
-        {{- reasoning_instructions + '\n\n' }}
-    {%- endif %}
-    {{- '# Tools\n\nYou have access to the following functions:\n\n<tools>' }}
-    {%- for tool in tools %}
-        {{- '\n' }}
-        {{- tool | tojson }}
-    {%- endfor %}
-    {{- '\n</tools>' }}
-    {%- if _tool_format == 'json' %}
-        {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<think>\nBrief explanation of tool call\n</think>\n<tool_call>\n{"name": "example_function_name", "arguments": {"example_parameter_1": "value_1", "example_parameter_2": "This is the value for the second parameter"}}\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user.\n- ALL explanation and reasoning MUST be placed strictly inside the <think></think> block.\n- Function calls MUST follow the specified format: a single JSON object with "name" and "arguments" keys inside <tool_call></tool_call> XML tags.\n- If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after thinking, with NO conversational text before it.\n- The <tool_call> tag MUST be at the very beginning of a new line, with NO spaces or indentation before it.\n- To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks.\n- If you have all necessary data, provide your final answer directly to the user without any tool call.\n</IMPORTANT>' }}
-    {%- else %}
-        {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<think>\nBrief explanation of tool call\n</think>\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user.\n- ALL explanation and reasoning MUST be placed strictly inside the <think></think> block.\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags.\n- If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after thinking, with NO conversational text before it.\n- The <tool_call> and <function> tags MUST be at the very beginning of a new line, with NO spaces or indentation before them.\n- To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks.\n- If you have all necessary data, provide your final answer directly to the user without any tool call.\n</IMPORTANT>' }}
-    {%- endif %}
-    {%- if _sc %}
-        {{- '\n\n' + _sc }}
-    {%- endif %}
-    {{- '<|im_end|>\n' }}
-{%- else %}
-    {%- if _sc %}
-        {{- '<|im_start|>system\n' + (reasoning_instructions + '\n\n' if reasoning_instructions else '') + _sc + '<|im_end|>\n' }}
-    {%- elif reasoning_instructions %}
-        {{- '<|im_start|>system\n' + reasoning_instructions + '<|im_end|>\n' }}
-    {%- endif %}
-{%- endif %}
-{%- set _last_idx = _msgs | length - 1 %}
-{%- set ns = namespace(multi_step_tool=true, last_query_index=_last_idx) %}
-{%- for message in _msgs[::-1] %}
-    {%- set index = (_msgs | length - 1) - loop.index0 %}
-    {%- if ns.multi_step_tool and message.role == 'user' %}
-        {%- set _rc = render_content(message.content, false) | trim %}
-        {%- if not (_rc.startswith('<tool_response>') and _rc.endswith('</tool_response>')) %}
-            {%- set ns.multi_step_tool = false %}
-            {%- set ns.last_query_index = index %}
-        {%- endif %}
-    {%- endif %}
-{%- endfor %}
-{%- if ns.multi_step_tool %}
-    {%- if _last_idx > 50 %}
-        {%- set ns.last_query_index = _last_idx %}
-    {%- else %}
-        {%- set ns.last_query_index = 0 %}
-    {%- endif %}
-{%- endif %}
-{%- set ns2 = namespace(prev_role='', consecutive_failures=0) %}
-{%- for message in _msgs %}
-    {%- set is_system = (message.role == "system" or message.role == "developer") %}
-    {%- set content = render_content(message.content, true, is_system) | trim %}
-    {%- if is_system or message.role == 'user' %}
-        {%- if '<|think_off|>' in content %}{%- set content = content.split('<|think_off|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_on|>' in content %}{%- set content = content.split('<|think_on|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_xhigh|>' in content %}{%- set content = content.split('<|think_xhigh|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_high|>' in content %}{%- set content = content.split('<|think_high|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_medium|>' in content %}{%- set content = content.split('<|think_medium|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_low|>' in content %}{%- set content = content.split('<|think_low|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_minimal|>' in content %}{%- set content = content.split('<|think_minimal|>') | join('') | trim %}{%- endif %}
-    {%- endif %}
-    {%- if is_system %}
-        {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}
-    {%- elif message.role == 'user' %}
-        {%- set ns2.consecutive_failures = 0 %}
-        {{- '<|im_start|>user\n' + content + '<|im_end|>\n' }}
-    {%- elif message.role == 'assistant' %}
-        {%- set reasoning_content = '' %}
-        {%- if message.reasoning_content is defined and message.reasoning_content is not none %}
-            {%- if message.reasoning_content is string %}
-                {%- set reasoning_content = message.reasoning_content %}
-            {%- else %}
-                {%- set reasoning_content = message.reasoning_content | string %}
-            {%- endif %}
-        {%- elif message.thinking is defined and message.thinking is not none %}
-            {%- if message.thinking is string %}
-                {%- set reasoning_content = message.thinking %}
-            {%- else %}
-                {%- set reasoning_content = message.thinking | string %}
-            {%- endif %}
-        {%- else %}
-            {%- set _think_end = '' %}
-            {%- if content.startswith('</think>') %}
-                {%- set _think_end = '</think>' %}
-            {%- elif content.startswith('</thinking>') %}
-                {%- set _think_end = '</thinking>' %}
-            {%- elif '\n</think>' in content %}
-                {%- set _think_end = '\n</think>' %}
-            {%- elif '\n</thinking>' in content %}
-                {%- set _think_end = '\n</thinking>' %}
-            {%- elif '\n</ think>' in content %}
-                {%- set _think_end = '\n</ think>' %}
-            {%- elif '\n</think >' in content %}
-                {%- set _think_end = '\n</think >' %}
-            {%- endif %}
-            {%- if _think_end %}
-                {%- if 'thinking' in _think_end %}
-                    {%- set _think_start = '<thinking>' %}
-                {%- else %}
-                    {%- set _think_start = '<think>' %}
-                {%- endif %}
-                {%- set reasoning_content = content.split(_think_end)[0].rstrip('\n') %}
-                {%- if _think_start in reasoning_content %}
-                    {%- set reasoning_content = reasoning_content.split(_think_start)[-1].lstrip('\n') %}
-                {%- endif %}
-                {%- set content = content.split(_think_end)[-1].lstrip('\n') %}
-            {%- endif %}
-        {%- endif %}
-        {%- set reasoning_content = reasoning_content | trim %}
-        {%- if (_preserve_thinking or loop.index0 > ns.last_query_index) and reasoning_content %}
-            {{- '<|im_start|>assistant\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}
-        {%- else %}
-            {{- '<|im_start|>assistant\n' + content }}
-        {%- endif %}
-        {%- if message.tool_calls is defined and message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}
-            {%- for tool_call in message.tool_calls %}
-                {%- if tool_call.function is defined and tool_call.function is not none %}
-                    {%- set tc = tool_call.function %}
-                {%- else %}
-                    {%- set tc = tool_call %}
-                {%- endif %}
-                {%- set tc_name = tc.name if (tc.name is defined and tc.name is not none) else '' %}
-                {%- if _tool_format == 'json' %}
-                    {%- if not loop.first or content | trim %}
-                        {{- '\n\n' }}
-                    {%- endif %}
-                    {%- set _args = '{}' %}
-                    {%- if tc.arguments is defined and tc.arguments is not none %}
-                        {%- if tc.arguments is mapping %}
-                            {%- set _args = tc.arguments | tojson %}
-                        {%- elif tc.arguments is string and tc.arguments %}
-                            {%- set _args = tc.arguments %}
-                        {%- endif %}
-                    {%- endif %}
-                    {{- '<tool_call>\n{"name": ' }}{{- tc_name | tojson }}{{- ', "arguments": ' }}{{- _args }}{{- '}\n</tool_call>' }}
-                {%- else %}
-                    {%- if loop.first %}
-                        {%- if content | trim %}
-                            {{- '\n\n<tool_call>\n<function=' + tc_name + '>\n' }}
-                        {%- else %}
-                            {{- '<tool_call>\n<function=' + tc_name + '>\n' }}
-                        {%- endif %}
-                    {%- else %}
-                        {{- '\n\n<tool_call>\n<function=' + tc_name + '>\n' }}
-                    {%- endif %}
-                    {%- if tc.arguments is defined and tc.arguments is not none %}
-                        {%- if tc.arguments is mapping %}
-                            {%- for args_name, args_value in tc.arguments.items() %}
-                                {{- '<parameter=' + args_name + '>\n' }}
-                                {%- if args_value is mapping or (args_value is sequence and args_value is not string) %}
-                                    {%- set _av = args_value | tojson %}
-                                {%- else %}
-                                    {%- set _av = args_value | string %}
-                                {%- endif %}
-                                {%- if max_tool_arg_chars > 0 and _av | length > max_tool_arg_chars %}
-                                    {{- _av[:max_tool_arg_chars] + '\n[TRUNCATED - original length ' ~ (_av | length | string) ~ ' chars]' }}
-                                {%- else %}
-                                    {{- _av }}
-                                {%- endif %}
-                                {{- '\n</parameter>\n' }}
-                            {%- endfor %}
-                        {%- elif tc.arguments is string and tc.arguments %}
-                            {{- tc.arguments }}
-                        {%- endif %}
-                    {%- endif %}
-                    {{- '</function>\n</tool_call>' }}
-                {%- endif %}
-            {%- endfor %}
-        {%- endif %}
-        {{- '<|im_end|>\n' }}
-    {%- elif message.role == 'tool' %}
-        {%- set _content_lower = content | lower %}
-        {%- set _content_head = _content_lower[:80] %}
-        {%- if content | length < 500 and '$ ' not in content and 'took ' not in _content_lower and ('"error":' in _content_head or 'error:' in _content_head or 'err!' in _content_head or 'fatal:' in _content_head or 'exception:' in _content_head or 'traceback' in _content_head or 'command not found' in _content_head or 'invalid syntax' in _content_head or 'failed to' in _content_head) %}
-            {%- set ns2.consecutive_failures = ns2.consecutive_failures + 1 %}
-        {%- else %}
-            {%- set ns2.consecutive_failures = 0 %}
-        {%- endif %}
-        {%- if ns2.prev_role != 'tool' %}
-            {{- '<|im_start|>user' }}
-        {%- endif %}
-        {%- if max_tool_response_chars > 0 and content | length > max_tool_response_chars %}
-            {%- set content = content[:max_tool_response_chars] + '\n[TRUNCATED - original length ' ~ (content | length | string) ~ ' chars]' %}
-        {%- endif %}
-        {{- '\n<tool_response>\n' + content }}
-        {%- if ns2.consecutive_failures >= 2 %}
-            {{- '\n\n⚠️ SYSTEM WARNING: ' ~ ns2.consecutive_failures ~ ' consecutive tool errors detected. Your previous approach is incorrect. You MUST use a fundamentally different approach or corrected arguments.' }}
-        {%- elif ns2.consecutive_failures == 1 %}
-            {{- '\n\n⚠️ SYSTEM WARNING: The previous tool call returned an error. Diagnose the failure and retry with completely corrected arguments.' }}
-        {%- endif %}
-        {{- '\n</tool_response>' }}
-        {%- if loop.last %}
-            {{- '<|im_end|>\n' }}
-        {%- else %}
-            {%- set _next_role = _msgs[loop.index0 + 1].role %}
-            {%- if _next_role != 'tool' %}
-                {{- '<|im_end|>\n' }}
-            {%- endif %}
-        {%- endif %}
-    {%- else %}
-        {{- '<|im_start|>user\n[' + message.role + ']: ' + content + '<|im_end|>\n' }}
-    {%- endif %}
-    {%- set ns2.prev_role = message.role %}
-{%- endfor %}
-{%- if add_generation_prompt %}
-    {{- '<|im_start|>assistant\n' }}
-    {%- if not ns_state.thinking %}
-        {{- '<think>\n\n</think>\n\n' }}
-    {%- else %}
-        {{- '<think>\n' }}
-    {%- endif %}
-{%- endif %}

archive/v22.1_chat_template_oneline.txt

@@ -1 +0,0 @@
-{%- set template_version = "qwen3.8-froggeric-v22.1" %}{%- set _tool_format = tool_call_format if tool_call_format is defined else 'xml' %}{%- set image_count = namespace(value=0) %}{%- set video_count = namespace(value=0) %}{%- set add_vision_id = add_vision_id if add_vision_id is defined else false %}{%- set enable_thinking = enable_thinking if enable_thinking is defined else true %}{%- set auto_disable_thinking_with_tools = auto_disable_thinking_with_tools if auto_disable_thinking_with_tools is defined else false %}{%- if preserve_reasoning is defined and preserve_reasoning is not none %}{%- set _preserve_thinking = preserve_reasoning %}{%- elif preserve_thinking is defined and preserve_thinking is not none %}{%- set _preserve_thinking = preserve_thinking %}{%- else %}{%- set _preserve_thinking = true %}{%- endif %}{%- set max_tool_arg_chars = max_tool_arg_chars if max_tool_arg_chars is defined else 0 %}{%- set max_tool_response_chars = max_tool_response_chars if max_tool_response_chars is defined else 0 %}{%- set _has_tools = (tools is defined and tools and tools is iterable and tools is not mapping) %}{%- set _effort_raw = (reasoning_effort | string | lower) if reasoning_effort is defined and reasoning_effort is not none else 'medium' %}{%- set _initial_thinking = enable_thinking %}{%- set _initial_effort = 'medium' %}{%- if _effort_raw == 'none' %}{%- set _initial_thinking = false %}{%- set _initial_effort = 'medium' %}{%- elif _effort_raw == 'minimal' or _effort_raw == 'low' %}{%- set _initial_effort = 'low' %}{%- elif _effort_raw == 'high' or _effort_raw == 'xhigh' or _effort_raw == 'max' %}{%- set _initial_effort = 'xhigh' %}{%- else %}{%- set _initial_effort = 'medium' %}{%- endif %}{%- set ns_state = namespace(thinking=_initial_thinking, effort=_initial_effort) %}{%- if auto_disable_thinking_with_tools and _has_tools %}{%- set ns_state.thinking = false %}{%- endif %}{%- for msg in messages %}{%- if msg.role == 'system' or msg.role == 'developer' or msg.role == 'user' %}{%- if msg.content is string %}{%- if '<|think_off|>' in msg.content %}{%- set ns_state.thinking = false %}{%- elif '<|think_on|>' in msg.content %}{%- set ns_state.thinking = true %}{%- elif '<|think_xhigh|>' in msg.content or '<|think_high|>' in msg.content %}{%- set ns_state.thinking = true %}{%- set ns_state.effort = 'xhigh' %}{%- elif '<|think_low|>' in msg.content or '<|think_minimal|>' in msg.content %}{%- set ns_state.thinking = true %}{%- set ns_state.effort = 'low' %}{%- elif '<|think_medium|>' in msg.content %}{%- set ns_state.thinking = true %}{%- set ns_state.effort = 'medium' %}{%- endif %}{%- elif msg.content is iterable and msg.content is not mapping %}{%- for item in msg.content %}{%- if item is string %}{%- set _item_text = item %}{%- elif item is mapping and 'text' in item and item.text is string %}{%- set _item_text = item.text %}{%- else %}{%- set _item_text = '' %}{%- endif %}{%- if _item_text %}{%- if '<|think_off|>' in _item_text %}{%- set ns_state.thinking = false %}{%- elif '<|think_on|>' in _item_text %}{%- set ns_state.thinking = true %}{%- elif '<|think_xhigh|>' in _item_text or '<|think_high|>' in _item_text %}{%- set ns_state.thinking = true %}{%- set ns_state.effort = 'xhigh' %}{%- elif '<|think_low|>' in _item_text or '<|think_minimal|>' in _item_text %}{%- set ns_state.thinking = true %}{%- set ns_state.effort = 'low' %}{%- elif '<|think_medium|>' in _item_text %}{%- set ns_state.thinking = true %}{%- set ns_state.effort = 'medium' %}{%- endif %}{%- endif %}{%- endfor %}{%- endif %}{%- endif %}{%- endfor %}{%- set reasoning_instructions = '' %}{%- if ns_state.thinking %}{%- if ns_state.effort == 'xhigh' %}{%- set reasoning_instructions = 'Reasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.' %}{%- elif ns_state.effort == 'low' %}{%- set reasoning_instructions = 'Reasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration.' %}{%- endif %}{%- endif %}{%- macro render_content(content, do_vision_count, is_system_content=false) %}{%- if content is string %}{{- content }}{%- elif content is iterable and content is not mapping %}{%- for item in content %}{%- if item is mapping %}{%- if item.type == 'image' or 'image' in item or 'image_url' in item %}{%- if is_system_content %}{{- raise_exception('System message cannot contain images.') }}{%- endif %}{%- if do_vision_count %}{%- set image_count.value = image_count.value + 1 %}{%- endif %}{%- if add_vision_id %}{{- 'Picture ' ~ image_count.value ~ ': ' }}{%- endif %}{{- '<|vision_start|><|image_pad|><|vision_end|>' }}{%- elif item.type == 'video' or 'video' in item %}{%- if is_system_content %}{{- raise_exception('System message cannot contain videos.') }}{%- endif %}{%- if do_vision_count %}{%- set video_count.value = video_count.value + 1 %}{%- endif %}{%- if add_vision_id %}{{- 'Video ' ~ video_count.value ~ ': ' }}{%- endif %}{{- '<|vision_start|><|video_pad|><|vision_end|>' }}{%- elif 'text' in item %}{{- item.text }}{%- else %}{{- raise_exception('Unexpected item type in content.') }}{%- endif %}{%- else %}{{- item | string }}{%- endif %}{%- endfor %}{%- elif content is none or content is undefined %}{{- '' }}{%- else %}{{- raise_exception('Unexpected content type.') }}{%- endif %}{%- endmacro %}{%- if not messages %}{{- raise_exception('No messages provided.') }}{%- endif %}{%- set _first_role = messages[0].role %}{%- if _first_role == 'system' or _first_role == 'developer' %}{%- set _sys_msg = messages[0] %}{%- set _msgs = messages[1:] %}{%- else %}{%- set _sys_msg = none %}{%- set _msgs = messages %}{%- endif %}{%- set _sc = '' %}{%- if _sys_msg is not none %}{%- set _sc = render_content(_sys_msg.content, false, true) | trim %}{%- if '<|think_off|>' in _sc %}{%- set _sc = _sc.split('<|think_off|>') | join('') | trim %}{%- endif %}{%- if '<|think_on|>' in _sc %}{%- set _sc = _sc.split('<|think_on|>') | join('') | trim %}{%- endif %}{%- if '<|think_xhigh|>' in _sc %}{%- set _sc = _sc.split('<|think_xhigh|>') | join('') | trim %}{%- endif %}{%- if '<|think_high|>' in _sc %}{%- set _sc = _sc.split('<|think_high|>') | join('') | trim %}{%- endif %}{%- if '<|think_medium|>' in _sc %}{%- set _sc = _sc.split('<|think_medium|>') | join('') | trim %}{%- endif %}{%- if '<|think_low|>' in _sc %}{%- set _sc = _sc.split('<|think_low|>') | join('') | trim %}{%- endif %}{%- if '<|think_minimal|>' in _sc %}{%- set _sc = _sc.split('<|think_minimal|>') | join('') | trim %}{%- endif %}{%- endif %}{%- if _has_tools %}{{- '<|im_start|>system\n' }}{%- if reasoning_instructions %}{{- reasoning_instructions + '\n\n' }}{%- endif %}{{- '# Tools\n\nYou have access to the following functions:\n\n<tools>' }}{%- for tool in tools %}{{- '\n' }}{{- tool | tojson }}{%- endfor %}{{- '\n</tools>' }}{%- if _tool_format == 'json' %}{{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<think>\nBrief explanation of tool call\n</think>\n<tool_call>\n{"name": "example_function_name", "arguments": {"example_parameter_1": "value_1", "example_parameter_2": "This is the value for the second parameter"}}\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user.\n- ALL explanation and reasoning MUST be placed strictly inside the <think></think> block.\n- Function calls MUST follow the specified format: a single JSON object with "name" and "arguments" keys inside <tool_call></tool_call> XML tags.\n- If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after thinking, with NO conversational text before it.\n- The <tool_call> tag MUST be at the very beginning of a new line, with NO spaces or indentation before it.\n- To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks.\n- If you have all necessary data, provide your final answer directly to the user without any tool call.\n</IMPORTANT>' }}{%- else %}{{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<think>\nBrief explanation of tool call\n</think>\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user.\n- ALL explanation and reasoning MUST be placed strictly inside the <think></think> block.\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags.\n- If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after thinking, with NO conversational text before it.\n- The <tool_call> and <function> tags MUST be at the very beginning of a new line, with NO spaces or indentation before them.\n- To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks.\n- If you have all necessary data, provide your final answer directly to the user without any tool call.\n</IMPORTANT>' }}{%- endif %}{%- if _sc %}{{- '\n\n' + _sc }}{%- endif %}{{- '<|im_end|>\n' }}{%- else %}{%- if _sc %}{{- '<|im_start|>system\n' + (reasoning_instructions + '\n\n' if reasoning_instructions else '') + _sc + '<|im_end|>\n' }}{%- elif reasoning_instructions %}{{- '<|im_start|>system\n' + reasoning_instructions + '<|im_end|>\n' }}{%- endif %}{%- endif %}{%- set _last_idx = _msgs | length - 1 %}{%- set ns = namespace(multi_step_tool=true, last_query_index=_last_idx) %}{%- for message in _msgs[::-1] %}{%- set index = (_msgs | length - 1) - loop.index0 %}{%- if ns.multi_step_tool and message.role == 'user' %}{%- set _rc = render_content(message.content, false) | trim %}{%- if not (_rc.startswith('<tool_response>') and _rc.endswith('</tool_response>')) %}{%- set ns.multi_step_tool = false %}{%- set ns.last_query_index = index %}{%- endif %}{%- endif %}{%- endfor %}{%- if ns.multi_step_tool %}{%- if _last_idx > 50 %}{%- set ns.last_query_index = _last_idx %}{%- else %}{%- set ns.last_query_index = 0 %}{%- endif %}{%- endif %}{%- set ns2 = namespace(prev_role='', consecutive_failures=0) %}{%- for message in _msgs %}{%- set is_system = (message.role == "system" or message.role == "developer") %}{%- set content = render_content(message.content, true, is_system) | trim %}{%- if is_system or message.role == 'user' %}{%- if '<|think_off|>' in content %}{%- set content = content.split('<|think_off|>') | join('') | trim %}{%- endif %}{%- if '<|think_on|>' in content %}{%- set content = content.split('<|think_on|>') | join('') | trim %}{%- endif %}{%- if '<|think_xhigh|>' in content %}{%- set content = content.split('<|think_xhigh|>') | join('') | trim %}{%- endif %}{%- if '<|think_high|>' in content %}{%- set content = content.split('<|think_high|>') | join('') | trim %}{%- endif %}{%- if '<|think_medium|>' in content %}{%- set content = content.split('<|think_medium|>') | join('') | trim %}{%- endif %}{%- if '<|think_low|>' in content %}{%- set content = content.split('<|think_low|>') | join('') | trim %}{%- endif %}{%- if '<|think_minimal|>' in content %}{%- set content = content.split('<|think_minimal|>') | join('') | trim %}{%- endif %}{%- endif %}{%- if is_system %}{{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}{%- elif message.role == 'user' %}{%- set ns2.consecutive_failures = 0 %}{{- '<|im_start|>user\n' + content + '<|im_end|>\n' }}{%- elif message.role == 'assistant' %}{%- set reasoning_content = '' %}{%- if message.reasoning_content is defined and message.reasoning_content is not none %}{%- if message.reasoning_content is string %}{%- set reasoning_content = message.reasoning_content %}{%- else %}{%- set reasoning_content = message.reasoning_content | string %}{%- endif %}{%- elif message.thinking is defined and message.thinking is not none %}{%- if message.thinking is string %}{%- set reasoning_content = message.thinking %}{%- else %}{%- set reasoning_content = message.thinking | string %}{%- endif %}{%- else %}{%- set _think_end = '' %}{%- if content.startswith('</think>') %}{%- set _think_end = '</think>' %}{%- elif content.startswith('</thinking>') %}{%- set _think_end = '</thinking>' %}{%- elif '\n</think>' in content %}{%- set _think_end = '\n</think>' %}{%- elif '\n</thinking>' in content %}{%- set _think_end = '\n</thinking>' %}{%- elif '\n</ think>' in content %}{%- set _think_end = '\n</ think>' %}{%- elif '\n</think >' in content %}{%- set _think_end = '\n</think >' %}{%- endif %}{%- if _think_end %}{%- if 'thinking' in _think_end %}{%- set _think_start = '<thinking>' %}{%- else %}{%- set _think_start = '<think>' %}{%- endif %}{%- set reasoning_content = content.split(_think_end)[0].rstrip('\n') %}{%- if _think_start in reasoning_content %}{%- set reasoning_content = reasoning_content.split(_think_start)[-1].lstrip('\n') %}{%- endif %}{%- set content = content.split(_think_end)[-1].lstrip('\n') %}{%- endif %}{%- endif %}{%- set reasoning_content = reasoning_content | trim %}{%- if (_preserve_thinking or loop.index0 > ns.last_query_index) and reasoning_content %}{{- '<|im_start|>assistant\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}{%- else %}{{- '<|im_start|>assistant\n' + content }}{%- endif %}{%- if message.tool_calls is defined and message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}{%- for tool_call in message.tool_calls %}{%- if tool_call.function is defined and tool_call.function is not none %}{%- set tc = tool_call.function %}{%- else %}{%- set tc = tool_call %}{%- endif %}{%- set tc_name = tc.name if (tc.name is defined and tc.name is not none) else '' %}{%- if _tool_format == 'json' %}{%- if not loop.first or content | trim %}{{- '\n\n' }}{%- endif %}{%- set _args = '{}' %}{%- if tc.arguments is defined and tc.arguments is not none %}{%- if tc.arguments is mapping %}{%- set _args = tc.arguments | tojson %}{%- elif tc.arguments is string and tc.arguments %}{%- set _args = tc.arguments %}{%- endif %}{%- endif %}{{- '<tool_call>\n{"name": ' }}{{- tc_name | tojson }}{{- ', "arguments": ' }}{{- _args }}{{- '}\n</tool_call>' }}{%- else %}{%- if loop.first %}{%- if content | trim %}{{- '\n\n<tool_call>\n<function=' + tc_name + '>\n' }}{%- else %}{{- '<tool_call>\n<function=' + tc_name + '>\n' }}{%- endif %}{%- else %}{{- '\n\n<tool_call>\n<function=' + tc_name + '>\n' }}{%- endif %}{%- if tc.arguments is defined and tc.arguments is not none %}{%- if tc.arguments is mapping %}{%- for args_name, args_value in tc.arguments.items() %}{{- '<parameter=' + args_name + '>\n' }}{%- if args_value is mapping or (args_value is sequence and args_value is not string) %}{%- set _av = args_value | tojson %}{%- else %}{%- set _av = args_value | string %}{%- endif %}{%- if max_tool_arg_chars > 0 and _av | length > max_tool_arg_chars %}{{- _av[:max_tool_arg_chars] + '\n[TRUNCATED - original length ' ~ (_av | length | string) ~ ' chars]' }}{%- else %}{{- _av }}{%- endif %}{{- '\n</parameter>\n' }}{%- endfor %}{%- elif tc.arguments is string and tc.arguments %}{{- tc.arguments }}{%- endif %}{%- endif %}{{- '</function>\n</tool_call>' }}{%- endif %}{%- endfor %}{%- endif %}{{- '<|im_end|>\n' }}{%- elif message.role == 'tool' %}{%- set _content_lower = content | lower %}{%- set _content_head = _content_lower[:80] %}{%- if content | length < 500 and '$ ' not in content and 'took ' not in _content_lower and ('"error":' in _content_head or 'error:' in _content_head or 'err!' in _content_head or 'fatal:' in _content_head or 'exception:' in _content_head or 'traceback' in _content_head or 'command not found' in _content_head or 'invalid syntax' in _content_head or 'failed to' in _content_head) %}{%- set ns2.consecutive_failures = ns2.consecutive_failures + 1 %}{%- else %}{%- set ns2.consecutive_failures = 0 %}{%- endif %}{%- if ns2.prev_role != 'tool' %}{{- '<|im_start|>user' }}{%- endif %}{%- if max_tool_response_chars > 0 and content | length > max_tool_response_chars %}{%- set content = content[:max_tool_response_chars] + '\n[TRUNCATED - original length ' ~ (content | length | string) ~ ' chars]' %}{%- endif %}{{- '\n<tool_response>\n' + content }}{%- if ns2.consecutive_failures >= 2 %}{{- '\n\n⚠️ SYSTEM WARNING: ' ~ ns2.consecutive_failures ~ ' consecutive tool errors detected. Your previous approach is incorrect. You MUST use a fundamentally different approach or corrected arguments.' }}{%- elif ns2.consecutive_failures == 1 %}{{- '\n\n⚠️ SYSTEM WARNING: The previous tool call returned an error. Diagnose the failure and retry with completely corrected arguments.' }}{%- endif %}{{- '\n</tool_response>' }}{%- if loop.last %}{{- '<|im_end|>\n' }}{%- else %}{%- set _next_role = _msgs[loop.index0 + 1].role %}{%- if _next_role != 'tool' %}{{- '<|im_end|>\n' }}{%- endif %}{%- endif %}{%- else %}{{- '<|im_start|>user\n[' + message.role + ']: ' + content + '<|im_end|>\n' }}{%- endif %}{%- set ns2.prev_role = message.role %}{%- endfor %}{%- if add_generation_prompt %}{{- '<|im_start|>assistant\n' }}{%- if not ns_state.thinking %}{{- '<think>\n\n</think>\n\n' }}{%- else %}{{- '<think>\n' }}{%- endif %}{%- endif %}

archive/v22.2_chat_template.jinja

@@ -1,380 +0,0 @@
-{%- set template_version = "qwen3.8-froggeric-v22.2" %}
-{%- set _tool_format = tool_call_format if tool_call_format is defined else 'xml' %}
-{%- set image_count = namespace(value=0) %}
-{%- set video_count = namespace(value=0) %}
-{%- set add_vision_id = add_vision_id if add_vision_id is defined else false %}
-{%- set enable_thinking = enable_thinking if enable_thinking is defined else true %}
-{%- set auto_disable_thinking_with_tools = auto_disable_thinking_with_tools if auto_disable_thinking_with_tools is defined else false %}
-{%- if preserve_reasoning is defined and preserve_reasoning is not none %}
-    {%- set _preserve_thinking = preserve_reasoning %}
-{%- elif preserve_thinking is defined and preserve_thinking is not none %}
-    {%- set _preserve_thinking = preserve_thinking %}
-{%- else %}
-    {%- set _preserve_thinking = true %}
-{%- endif %}
-{%- set max_tool_arg_chars = max_tool_arg_chars if max_tool_arg_chars is defined else 0 %}
-{%- set max_tool_response_chars = max_tool_response_chars if max_tool_response_chars is defined else 0 %}
-{%- set _has_tools = (tools is defined and tools and tools is iterable and tools is not mapping) %}
-{%- set _effort_raw = (reasoning_effort | string | lower) if reasoning_effort is defined and reasoning_effort is not none else 'medium' %}
-{%- set _initial_thinking = enable_thinking %}
-{%- set _initial_effort = 'medium' %}
-{%- if _effort_raw in ('none', 'off') %}
-    {%- set _initial_thinking = false %}
-    {%- set _initial_effort = 'medium' %}
-{%- elif _effort_raw in ('minimal', 'low') %}
-    {%- set _initial_effort = 'low' %}
-{%- elif _effort_raw in ('high', 'xhigh', 'max', 'ultracode', 'extreme') %}
-    {%- set _initial_effort = 'xhigh' %}
-{%- else %}
-    {%- set _initial_effort = 'medium' %}
-{%- endif %}
-{%- set ns_state = namespace(thinking=_initial_thinking, effort=_initial_effort) %}
-{%- if auto_disable_thinking_with_tools and _has_tools %}
-    {%- set ns_state.thinking = false %}
-{%- endif %}
-{%- for msg in messages %}
-    {%- if msg.role == 'system' or msg.role == 'developer' or msg.role == 'user' %}
-        {%- if msg.content is string %}
-            {%- if '<|think_off|>' in msg.content %}
-                {%- set ns_state.thinking = false %}
-            {%- elif '<|think_on|>' in msg.content %}
-                {%- set ns_state.thinking = true %}
-            {%- elif '<|think_xhigh|>' in msg.content or '<|think_high|>' in msg.content or '<|think_ultracode|>' in msg.content or '<|think_extreme|>' in msg.content or '<|think_max|>' in msg.content %}
-                {%- set ns_state.thinking = true %}
-                {%- set ns_state.effort = 'xhigh' %}
-            {%- elif '<|think_low|>' in msg.content or '<|think_minimal|>' in msg.content %}
-                {%- set ns_state.thinking = true %}
-                {%- set ns_state.effort = 'low' %}
-            {%- elif '<|think_medium|>' in msg.content %}
-                {%- set ns_state.thinking = true %}
-                {%- set ns_state.effort = 'medium' %}
-            {%- endif %}
-        {%- elif msg.content is iterable and msg.content is not mapping %}
-            {%- for item in msg.content %}
-                {%- if item is string %}
-                    {%- set _item_text = item %}
-                {%- elif item is mapping and 'text' in item and item.text is string %}
-                    {%- set _item_text = item.text %}
-                {%- else %}
-                    {%- set _item_text = '' %}
-                {%- endif %}
-                {%- if _item_text %}
-                    {%- if '<|think_off|>' in _item_text %}
-                        {%- set ns_state.thinking = false %}
-                    {%- elif '<|think_on|>' in _item_text %}
-                        {%- set ns_state.thinking = true %}
-                    {%- elif '<|think_xhigh|>' in _item_text or '<|think_high|>' in _item_text or '<|think_ultracode|>' in _item_text or '<|think_extreme|>' in _item_text or '<|think_max|>' in _item_text %}
-                        {%- set ns_state.thinking = true %}
-                        {%- set ns_state.effort = 'xhigh' %}
-                    {%- elif '<|think_low|>' in _item_text or '<|think_minimal|>' in _item_text %}
-                        {%- set ns_state.thinking = true %}
-                        {%- set ns_state.effort = 'low' %}
-                    {%- elif '<|think_medium|>' in _item_text %}
-                        {%- set ns_state.thinking = true %}
-                        {%- set ns_state.effort = 'medium' %}
-                    {%- endif %}
-                {%- endif %}
-            {%- endfor %}
-        {%- endif %}
-    {%- endif %}
-{%- endfor %}
-{%- set reasoning_instructions = '' %}
-{%- if ns_state.thinking %}
-    {%- if ns_state.effort == 'xhigh' %}
-        {%- set reasoning_instructions = 'Reasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.' %}
-    {%- elif ns_state.effort == 'low' %}
-        {%- set reasoning_instructions = 'Reasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration.' %}
-    {%- endif %}
-{%- endif %}
-{%- macro render_content(content, do_vision_count, is_system_content=false) %}
-    {%- if content is string %}
-        {{- content }}
-    {%- elif content is iterable and content is not mapping %}
-        {%- for item in content %}
-            {%- if item is mapping %}
-                {%- if item.type == 'image' or 'image' in item or 'image_url' in item %}
-                    {%- if is_system_content %}
-                        {{- raise_exception('System message cannot contain images.') }}
-                    {%- endif %}
-                    {%- if do_vision_count %}
-                        {%- set image_count.value = image_count.value + 1 %}
-                    {%- endif %}
-                    {%- if add_vision_id %}
-                        {{- 'Picture ' ~ image_count.value ~ ': ' }}
-                    {%- endif %}
-                    {{- '<|vision_start|><|image_pad|><|vision_end|>' }}
-                {%- elif item.type == 'video' or 'video' in item %}
-                    {%- if is_system_content %}
-                        {{- raise_exception('System message cannot contain videos.') }}
-                    {%- endif %}
-                    {%- if do_vision_count %}
-                        {%- set video_count.value = video_count.value + 1 %}
-                    {%- endif %}
-                    {%- if add_vision_id %}
-                        {{- 'Video ' ~ video_count.value ~ ': ' }}
-                    {%- endif %}
-                    {{- '<|vision_start|><|video_pad|><|vision_end|>' }}
-                {%- elif 'text' in item %}
-                    {{- item.text }}
-                {%- else %}
-                    {{- raise_exception('Unexpected item type in content.') }}
-                {%- endif %}
-            {%- else %}
-                {{- item | string }}
-            {%- endif %}
-        {%- endfor %}
-    {%- elif content is none or content is undefined %}
-        {{- '' }}
-    {%- else %}
-        {{- raise_exception('Unexpected content type.') }}
-    {%- endif %}
-{%- endmacro %}
-{%- if not messages %}
-    {{- raise_exception('No messages provided.') }}
-{%- endif %}
-{%- set head = namespace(count=0, seen_non_system=false) %}
-{%- for message in messages %}
-    {%- set _is_sys = (message.role == 'system' or message.role == 'developer') %}
-    {%- if _is_sys and not head.seen_non_system %}
-        {%- set head.count = head.count + 1 %}
-    {%- else %}
-        {%- set head.seen_non_system = true %}
-    {%- endif %}
-{%- endfor %}
-{%- set sys_state = namespace(content='') %}
-{%- for message in messages[:head.count] %}
-    {%- set _part = render_content(message.content, false, true) | trim %}
-    {%- if '<|think_off|>' in _part %}{%- set _part = _part.split('<|think_off|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_on|>' in _part %}{%- set _part = _part.split('<|think_on|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_xhigh|>' in _part %}{%- set _part = _part.split('<|think_xhigh|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_high|>' in _part %}{%- set _part = _part.split('<|think_high|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_ultracode|>' in _part %}{%- set _part = _part.split('<|think_ultracode|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_extreme|>' in _part %}{%- set _part = _part.split('<|think_extreme|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_max|>' in _part %}{%- set _part = _part.split('<|think_max|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_medium|>' in _part %}{%- set _part = _part.split('<|think_medium|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_low|>' in _part %}{%- set _part = _part.split('<|think_low|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_minimal|>' in _part %}{%- set _part = _part.split('<|think_minimal|>') | join('') | trim %}{%- endif %}
-    {%- if _part %}
-        {%- if sys_state.content %}
-            {%- set sys_state.content = sys_state.content ~ '\n\n' ~ _part %}
-        {%- else %}
-            {%- set sys_state.content = _part %}
-        {%- endif %}
-    {%- endif %}
-{%- endfor %}
-{%- set _sc = sys_state.content %}
-{%- set _msgs = messages[head.count:] %}
-{%- if _has_tools %}
-    {{- '<|im_start|>system\n' }}
-    {%- if reasoning_instructions %}
-        {{- reasoning_instructions + '\n\n' }}
-    {%- endif %}
-    {{- '# Tools\n\nYou have access to the following functions:\n\n<tools>' }}
-    {%- for tool in tools %}
-        {{- '\n' }}
-        {{- tool | tojson }}
-    {%- endfor %}
-    {{- '\n</tools>' }}
-    {%- if _tool_format == 'json' %}
-        {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<think>\nBrief explanation of tool call\n</think>\n<tool_call>\n{"name": "example_function_name", "arguments": {"example_parameter_1": "value_1", "example_parameter_2": "This is the value for the second parameter"}}\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user.\n- ALL explanation and reasoning MUST be placed strictly inside the <think></think> block.\n- Function calls MUST follow the specified format: a single JSON object with "name" and "arguments" keys inside <tool_call></tool_call> XML tags.\n- If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after thinking, with NO conversational text before it.\n- The <tool_call> tag MUST be at the very beginning of a new line, with NO spaces or indentation before it.\n- To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks.\n- If you have all necessary data, provide your final answer directly to the user without any tool call.\n</IMPORTANT>' }}
-    {%- else %}
-        {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<think>\nBrief explanation of tool call\n</think>\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user.\n- ALL explanation and reasoning MUST be placed strictly inside the <think></think> block.\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags.\n- If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after thinking, with NO conversational text before it.\n- The <tool_call> and <function> tags MUST be at the very beginning of a new line, with NO spaces or indentation before them.\n- To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks.\n- If you have all necessary data, provide your final answer directly to the user without any tool call.\n</IMPORTANT>' }}
-    {%- endif %}
-    {%- if _sc %}
-        {{- '\n\n' + _sc }}
-    {%- endif %}
-    {{- '<|im_end|>\n' }}
-{%- else %}
-    {%- if _sc %}
-        {{- '<|im_start|>system\n' + (reasoning_instructions + '\n\n' if reasoning_instructions else '') + _sc + '<|im_end|>\n' }}
-    {%- elif reasoning_instructions %}
-        {{- '<|im_start|>system\n' + reasoning_instructions + '<|im_end|>\n' }}
-    {%- endif %}
-{%- endif %}
-{%- set _last_idx = _msgs | length - 1 %}
-{%- set ns = namespace(multi_step_tool=true, last_query_index=_last_idx) %}
-{%- for message in _msgs[::-1] %}
-    {%- set index = (_msgs | length - 1) - loop.index0 %}
-    {%- if ns.multi_step_tool and message.role == 'user' %}
-        {%- set _rc = render_content(message.content, false) | trim %}
-        {%- if not (_rc.startswith('<tool_response>') and _rc.endswith('</tool_response>')) %}
-            {%- set ns.multi_step_tool = false %}
-            {%- set ns.last_query_index = index %}
-        {%- endif %}
-    {%- endif %}
-{%- endfor %}
-{%- if ns.multi_step_tool %}
-    {%- if _last_idx > 50 %}
-        {%- set ns.last_query_index = _last_idx %}
-    {%- else %}
-        {%- set ns.last_query_index = 0 %}
-    {%- endif %}
-{%- endif %}
-{%- set ns2 = namespace(prev_role='', consecutive_failures=0) %}
-{%- for message in _msgs %}
-    {%- set is_system = (message.role == "system" or message.role == "developer") %}
-    {%- set content = render_content(message.content, true, is_system) | trim %}
-    {%- if is_system or message.role == 'user' %}
-        {%- if '<|think_off|>' in content %}{%- set content = content.split('<|think_off|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_on|>' in content %}{%- set content = content.split('<|think_on|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_xhigh|>' in content %}{%- set content = content.split('<|think_xhigh|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_high|>' in content %}{%- set content = content.split('<|think_high|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_ultracode|>' in content %}{%- set content = content.split('<|think_ultracode|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_extreme|>' in content %}{%- set content = content.split('<|think_extreme|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_max|>' in content %}{%- set content = content.split('<|think_max|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_medium|>' in content %}{%- set content = content.split('<|think_medium|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_low|>' in content %}{%- set content = content.split('<|think_low|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_minimal|>' in content %}{%- set content = content.split('<|think_minimal|>') | join('') | trim %}{%- endif %}
-    {%- endif %}
-    {%- if is_system %}
-        {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}
-    {%- elif message.role == 'user' %}
-        {%- set ns2.consecutive_failures = 0 %}
-        {{- '<|im_start|>user\n' + content + '<|im_end|>\n' }}
-    {%- elif message.role == 'assistant' %}
-        {%- set reasoning_content = '' %}
-        {%- if message.reasoning_content is defined and message.reasoning_content is not none %}
-            {%- if message.reasoning_content is string %}
-                {%- set reasoning_content = message.reasoning_content %}
-            {%- else %}
-                {%- set reasoning_content = message.reasoning_content | string %}
-            {%- endif %}
-        {%- elif message.thinking is defined and message.thinking is not none %}
-            {%- if message.thinking is string %}
-                {%- set reasoning_content = message.thinking %}
-            {%- else %}
-                {%- set reasoning_content = message.thinking | string %}
-            {%- endif %}
-        {%- else %}
-            {%- set _think_end = '' %}
-            {%- if content.startswith('</think>') %}
-                {%- set _think_end = '</think>' %}
-            {%- elif content.startswith('</thinking>') %}
-                {%- set _think_end = '</thinking>' %}
-            {%- elif '\n</think>' in content %}
-                {%- set _think_end = '\n</think>' %}
-            {%- elif '\n</thinking>' in content %}
-                {%- set _think_end = '\n</thinking>' %}
-            {%- elif '\n</ think>' in content %}
-                {%- set _think_end = '\n</ think>' %}
-            {%- elif '\n</think >' in content %}
-                {%- set _think_end = '\n</think >' %}
-            {%- endif %}
-            {%- if _think_end %}
-                {%- if 'thinking' in _think_end %}
-                    {%- set _think_start = '<thinking>' %}
-                {%- else %}
-                    {%- set _think_start = '<think>' %}
-                {%- endif %}
-                {%- set reasoning_content = content.split(_think_end)[0].rstrip('\n') %}
-                {%- if _think_start in reasoning_content %}
-                    {%- set reasoning_content = reasoning_content.split(_think_start)[-1].lstrip('\n') %}
-                {%- endif %}
-                {%- set content = content.split(_think_end)[-1].lstrip('\n') %}
-            {%- endif %}
-        {%- endif %}
-        {%- set reasoning_content = reasoning_content | trim %}
-        {%- if (_preserve_thinking or loop.index0 > ns.last_query_index) and reasoning_content %}
-            {{- '<|im_start|>assistant\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}
-        {%- else %}
-            {{- '<|im_start|>assistant\n' + content }}
-        {%- endif %}
-        {%- if message.tool_calls is defined and message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}
-            {%- for tool_call in message.tool_calls %}
-                {%- if tool_call.function is defined and tool_call.function is not none %}
-                    {%- set tc = tool_call.function %}
-                {%- else %}
-                    {%- set tc = tool_call %}
-                {%- endif %}
-                {%- set tc_name = tc.name if (tc.name is defined and tc.name is not none) else '' %}
-                {%- if _tool_format == 'json' %}
-                    {%- if not loop.first or content | trim %}
-                        {{- '\n\n' }}
-                    {%- endif %}
-                    {%- set _args = '{}' %}
-                    {%- if tc.arguments is defined and tc.arguments is not none %}
-                        {%- if tc.arguments is mapping %}
-                            {%- set _args = tc.arguments | tojson %}
-                        {%- elif tc.arguments is string and tc.arguments %}
-                            {%- set _args = tc.arguments %}
-                        {%- endif %}
-                    {%- endif %}
-                    {{- '<tool_call>\n{"name": ' }}{{- tc_name | tojson }}{{- ', "arguments": ' }}{{- _args }}{{- '}\n</tool_call>' }}
-                {%- else %}
-                    {%- if loop.first %}
-                        {%- if content | trim %}
-                            {{- '\n\n<tool_call>\n<function=' + tc_name + '>\n' }}
-                        {%- else %}
-                            {{- '<tool_call>\n<function=' + tc_name + '>\n' }}
-                        {%- endif %}
-                    {%- else %}
-                        {{- '\n\n<tool_call>\n<function=' + tc_name + '>\n' }}
-                    {%- endif %}
-                    {%- if tc.arguments is defined and tc.arguments is not none %}
-                        {%- if tc.arguments is mapping %}
-                            {%- for args_name, args_value in tc.arguments.items() %}
-                                {{- '<parameter=' + args_name + '>\n' }}
-                                {%- if args_value is string %}
-                                    {%- set _av = args_value %}
-                                {%- else %}
-                                    {%- set _av = args_value | tojson %}
-                                {%- endif %}
-                                {%- if max_tool_arg_chars > 0 and _av | length > max_tool_arg_chars %}
-                                    {{- _av[:max_tool_arg_chars] + '\n[TRUNCATED - original length ' ~ (_av | length | string) ~ ' chars]' }}
-                                {%- else %}
-                                    {{- _av }}
-                                {%- endif %}
-                                {{- '\n</parameter>\n' }}
-                            {%- endfor %}
-                        {%- elif tc.arguments is string and tc.arguments %}
-                            {{- tc.arguments }}
-                        {%- endif %}
-                    {%- endif %}
-                    {{- '</function>\n</tool_call>' }}
-                {%- endif %}
-            {%- endfor %}
-        {%- endif %}
-        {{- '<|im_end|>\n' }}
-    {%- elif message.role == 'tool' %}
-        {%- set _content_lower = content | lower %}
-        {%- set _content_head = _content_lower[:120] %}
-        {%- set _is_code_or_grep = ('throw new ' in _content_lower or 'throw error' in _content_lower or 'console.error' in _content_lower or 'logger.error' in _content_lower or 'logging.error' in _content_lower or 'import ' in _content_head or 'def ' in _content_head or 'function ' in _content_head) %}
-        {%- if not _is_code_or_grep and content | length < 600 and '$ ' not in content and 'took ' not in _content_lower and ('"error":' in _content_head or '"status": "error"' in _content_head or '"status":"error"' in _content_head or 'error:' in _content_head or 'err!' in _content_head or 'fatal:' in _content_head or 'traceback (most recent call last):' in _content_head or 'command not found' in _content_head or 'invalid syntax' in _content_head or _content_head.startswith('exception:') or _content_head.startswith('failed to ') or 'exit code: ' in _content_head or 'process exited with code' in _content_head) %}
-            {%- set ns2.consecutive_failures = ns2.consecutive_failures + 1 %}
-        {%- else %}
-            {%- set ns2.consecutive_failures = 0 %}
-        {%- endif %}
-        {%- if ns2.prev_role != 'tool' %}
-            {{- '<|im_start|>user' }}
-        {%- endif %}
-        {%- if max_tool_response_chars > 0 and content | length > max_tool_response_chars %}
-            {%- set content = content[:max_tool_response_chars] + '\n[TRUNCATED - original length ' ~ (content | length | string) ~ ' chars]' %}
-        {%- endif %}
-        {{- '\n<tool_response>\n' + content }}
-        {%- if ns2.consecutive_failures >= 2 %}
-            {{- '\n\n⚠️ SYSTEM WARNING: ' ~ ns2.consecutive_failures ~ ' consecutive tool errors detected. Your previous approach is incorrect. You MUST use a fundamentally different approach or corrected arguments.' }}
-        {%- elif ns2.consecutive_failures == 1 %}
-            {{- '\n\n⚠️ SYSTEM WARNING: The previous tool call returned an error. Diagnose the failure and retry with completely corrected arguments.' }}
-        {%- endif %}
-        {{- '\n</tool_response>' }}
-        {%- if loop.last %}
-            {{- '<|im_end|>\n' }}
-        {%- else %}
-            {%- set _next_role = _msgs[loop.index0 + 1].role %}
-            {%- if _next_role != 'tool' %}
-                {{- '<|im_end|>\n' }}
-            {%- endif %}
-        {%- endif %}
-    {%- else %}
-        {{- '<|im_start|>user\n[' + message.role + ']: ' + content + '<|im_end|>\n' }}
-    {%- endif %}
-    {%- set ns2.prev_role = message.role %}
-{%- endfor %}
-{%- if add_generation_prompt %}
-    {{- '<|im_start|>assistant\n' }}
-    {%- if not ns_state.thinking %}
-        {{- '<think>\n\n</think>\n\n' }}
-    {%- else %}
-        {{- '<think>\n' }}
-    {%- endif %}
-{%- endif %}

archive/v22.2_chat_template_oneline.txt

@@ -1 +0,0 @@
-{%- set template_version = "qwen3.8-froggeric-v22.2" %}{%- set _tool_format = tool_call_format if tool_call_format is defined else 'xml' %}{%- set image_count = namespace(value=0) %}{%- set video_count = namespace(value=0) %}{%- set add_vision_id = add_vision_id if add_vision_id is defined else false %}{%- set enable_thinking = enable_thinking if enable_thinking is defined else true %}{%- set auto_disable_thinking_with_tools = auto_disable_thinking_with_tools if auto_disable_thinking_with_tools is defined else false %}{%- if preserve_reasoning is defined and preserve_reasoning is not none %}{%- set _preserve_thinking = preserve_reasoning %}{%- elif preserve_thinking is defined and preserve_thinking is not none %}{%- set _preserve_thinking = preserve_thinking %}{%- else %}{%- set _preserve_thinking = true %}{%- endif %}{%- set max_tool_arg_chars = max_tool_arg_chars if max_tool_arg_chars is defined else 0 %}{%- set max_tool_response_chars = max_tool_response_chars if max_tool_response_chars is defined else 0 %}{%- set _has_tools = (tools is defined and tools and tools is iterable and tools is not mapping) %}{%- set _effort_raw = (reasoning_effort | string | lower) if reasoning_effort is defined and reasoning_effort is not none else 'medium' %}{%- set _initial_thinking = enable_thinking %}{%- set _initial_effort = 'medium' %}{%- if _effort_raw in ('none', 'off') %}{%- set _initial_thinking = false %}{%- set _initial_effort = 'medium' %}{%- elif _effort_raw in ('minimal', 'low') %}{%- set _initial_effort = 'low' %}{%- elif _effort_raw in ('high', 'xhigh', 'max', 'ultracode', 'extreme') %}{%- set _initial_effort = 'xhigh' %}{%- else %}{%- set _initial_effort = 'medium' %}{%- endif %}{%- set ns_state = namespace(thinking=_initial_thinking, effort=_initial_effort) %}{%- if auto_disable_thinking_with_tools and _has_tools %}{%- set ns_state.thinking = false %}{%- endif %}{%- for msg in messages %}{%- if msg.role == 'system' or msg.role == 'developer' or msg.role == 'user' %}{%- if msg.content is string %}{%- if '<|think_off|>' in msg.content %}{%- set ns_state.thinking = false %}{%- elif '<|think_on|>' in msg.content %}{%- set ns_state.thinking = true %}{%- elif '<|think_xhigh|>' in msg.content or '<|think_high|>' in msg.content or '<|think_ultracode|>' in msg.content or '<|think_extreme|>' in msg.content or '<|think_max|>' in msg.content %}{%- set ns_state.thinking = true %}{%- set ns_state.effort = 'xhigh' %}{%- elif '<|think_low|>' in msg.content or '<|think_minimal|>' in msg.content %}{%- set ns_state.thinking = true %}{%- set ns_state.effort = 'low' %}{%- elif '<|think_medium|>' in msg.content %}{%- set ns_state.thinking = true %}{%- set ns_state.effort = 'medium' %}{%- endif %}{%- elif msg.content is iterable and msg.content is not mapping %}{%- for item in msg.content %}{%- if item is string %}{%- set _item_text = item %}{%- elif item is mapping and 'text' in item and item.text is string %}{%- set _item_text = item.text %}{%- else %}{%- set _item_text = '' %}{%- endif %}{%- if _item_text %}{%- if '<|think_off|>' in _item_text %}{%- set ns_state.thinking = false %}{%- elif '<|think_on|>' in _item_text %}{%- set ns_state.thinking = true %}{%- elif '<|think_xhigh|>' in _item_text or '<|think_high|>' in _item_text or '<|think_ultracode|>' in _item_text or '<|think_extreme|>' in _item_text or '<|think_max|>' in _item_text %}{%- set ns_state.thinking = true %}{%- set ns_state.effort = 'xhigh' %}{%- elif '<|think_low|>' in _item_text or '<|think_minimal|>' in _item_text %}{%- set ns_state.thinking = true %}{%- set ns_state.effort = 'low' %}{%- elif '<|think_medium|>' in _item_text %}{%- set ns_state.thinking = true %}{%- set ns_state.effort = 'medium' %}{%- endif %}{%- endif %}{%- endfor %}{%- endif %}{%- endif %}{%- endfor %}{%- set reasoning_instructions = '' %}{%- if ns_state.thinking %}{%- if ns_state.effort == 'xhigh' %}{%- set reasoning_instructions = 'Reasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.' %}{%- elif ns_state.effort == 'low' %}{%- set reasoning_instructions = 'Reasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration.' %}{%- endif %}{%- endif %}{%- macro render_content(content, do_vision_count, is_system_content=false) %}{%- if content is string %}{{- content }}{%- elif content is iterable and content is not mapping %}{%- for item in content %}{%- if item is mapping %}{%- if item.type == 'image' or 'image' in item or 'image_url' in item %}{%- if is_system_content %}{{- raise_exception('System message cannot contain images.') }}{%- endif %}{%- if do_vision_count %}{%- set image_count.value = image_count.value + 1 %}{%- endif %}{%- if add_vision_id %}{{- 'Picture ' ~ image_count.value ~ ': ' }}{%- endif %}{{- '<|vision_start|><|image_pad|><|vision_end|>' }}{%- elif item.type == 'video' or 'video' in item %}{%- if is_system_content %}{{- raise_exception('System message cannot contain videos.') }}{%- endif %}{%- if do_vision_count %}{%- set video_count.value = video_count.value + 1 %}{%- endif %}{%- if add_vision_id %}{{- 'Video ' ~ video_count.value ~ ': ' }}{%- endif %}{{- '<|vision_start|><|video_pad|><|vision_end|>' }}{%- elif 'text' in item %}{{- item.text }}{%- else %}{{- raise_exception('Unexpected item type in content.') }}{%- endif %}{%- else %}{{- item | string }}{%- endif %}{%- endfor %}{%- elif content is none or content is undefined %}{{- '' }}{%- else %}{{- raise_exception('Unexpected content type.') }}{%- endif %}{%- endmacro %}{%- if not messages %}{{- raise_exception('No messages provided.') }}{%- endif %}{%- set head = namespace(count=0, seen_non_system=false) %}{%- for message in messages %}{%- set _is_sys = (message.role == 'system' or message.role == 'developer') %}{%- if _is_sys and not head.seen_non_system %}{%- set head.count = head.count + 1 %}{%- else %}{%- set head.seen_non_system = true %}{%- endif %}{%- endfor %}{%- set sys_state = namespace(content='') %}{%- for message in messages[:head.count] %}{%- set _part = render_content(message.content, false, true) | trim %}{%- if '<|think_off|>' in _part %}{%- set _part = _part.split('<|think_off|>') | join('') | trim %}{%- endif %}{%- if '<|think_on|>' in _part %}{%- set _part = _part.split('<|think_on|>') | join('') | trim %}{%- endif %}{%- if '<|think_xhigh|>' in _part %}{%- set _part = _part.split('<|think_xhigh|>') | join('') | trim %}{%- endif %}{%- if '<|think_high|>' in _part %}{%- set _part = _part.split('<|think_high|>') | join('') | trim %}{%- endif %}{%- if '<|think_ultracode|>' in _part %}{%- set _part = _part.split('<|think_ultracode|>') | join('') | trim %}{%- endif %}{%- if '<|think_extreme|>' in _part %}{%- set _part = _part.split('<|think_extreme|>') | join('') | trim %}{%- endif %}{%- if '<|think_max|>' in _part %}{%- set _part = _part.split('<|think_max|>') | join('') | trim %}{%- endif %}{%- if '<|think_medium|>' in _part %}{%- set _part = _part.split('<|think_medium|>') | join('') | trim %}{%- endif %}{%- if '<|think_low|>' in _part %}{%- set _part = _part.split('<|think_low|>') | join('') | trim %}{%- endif %}{%- if '<|think_minimal|>' in _part %}{%- set _part = _part.split('<|think_minimal|>') | join('') | trim %}{%- endif %}{%- if _part %}{%- if sys_state.content %}{%- set sys_state.content = sys_state.content ~ '\n\n' ~ _part %}{%- else %}{%- set sys_state.content = _part %}{%- endif %}{%- endif %}{%- endfor %}{%- set _sc = sys_state.content %}{%- set _msgs = messages[head.count:] %}{%- if _has_tools %}{{- '<|im_start|>system\n' }}{%- if reasoning_instructions %}{{- reasoning_instructions + '\n\n' }}{%- endif %}{{- '# Tools\n\nYou have access to the following functions:\n\n<tools>' }}{%- for tool in tools %}{{- '\n' }}{{- tool | tojson }}{%- endfor %}{{- '\n</tools>' }}{%- if _tool_format == 'json' %}{{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<think>\nBrief explanation of tool call\n</think>\n<tool_call>\n{"name": "example_function_name", "arguments": {"example_parameter_1": "value_1", "example_parameter_2": "This is the value for the second parameter"}}\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user.\n- ALL explanation and reasoning MUST be placed strictly inside the <think></think> block.\n- Function calls MUST follow the specified format: a single JSON object with "name" and "arguments" keys inside <tool_call></tool_call> XML tags.\n- If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after thinking, with NO conversational text before it.\n- The <tool_call> tag MUST be at the very beginning of a new line, with NO spaces or indentation before it.\n- To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks.\n- If you have all necessary data, provide your final answer directly to the user without any tool call.\n</IMPORTANT>' }}{%- else %}{{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<think>\nBrief explanation of tool call\n</think>\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user.\n- ALL explanation and reasoning MUST be placed strictly inside the <think></think> block.\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags.\n- If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after thinking, with NO conversational text before it.\n- The <tool_call> and <function> tags MUST be at the very beginning of a new line, with NO spaces or indentation before them.\n- To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks.\n- If you have all necessary data, provide your final answer directly to the user without any tool call.\n</IMPORTANT>' }}{%- endif %}{%- if _sc %}{{- '\n\n' + _sc }}{%- endif %}{{- '<|im_end|>\n' }}{%- else %}{%- if _sc %}{{- '<|im_start|>system\n' + (reasoning_instructions + '\n\n' if reasoning_instructions else '') + _sc + '<|im_end|>\n' }}{%- elif reasoning_instructions %}{{- '<|im_start|>system\n' + reasoning_instructions + '<|im_end|>\n' }}{%- endif %}{%- endif %}{%- set _last_idx = _msgs | length - 1 %}{%- set ns = namespace(multi_step_tool=true, last_query_index=_last_idx) %}{%- for message in _msgs[::-1] %}{%- set index = (_msgs | length - 1) - loop.index0 %}{%- if ns.multi_step_tool and message.role == 'user' %}{%- set _rc = render_content(message.content, false) | trim %}{%- if not (_rc.startswith('<tool_response>') and _rc.endswith('</tool_response>')) %}{%- set ns.multi_step_tool = false %}{%- set ns.last_query_index = index %}{%- endif %}{%- endif %}{%- endfor %}{%- if ns.multi_step_tool %}{%- if _last_idx > 50 %}{%- set ns.last_query_index = _last_idx %}{%- else %}{%- set ns.last_query_index = 0 %}{%- endif %}{%- endif %}{%- set ns2 = namespace(prev_role='', consecutive_failures=0) %}{%- for message in _msgs %}{%- set is_system = (message.role == "system" or message.role == "developer") %}{%- set content = render_content(message.content, true, is_system) | trim %}{%- if is_system or message.role == 'user' %}{%- if '<|think_off|>' in content %}{%- set content = content.split('<|think_off|>') | join('') | trim %}{%- endif %}{%- if '<|think_on|>' in content %}{%- set content = content.split('<|think_on|>') | join('') | trim %}{%- endif %}{%- if '<|think_xhigh|>' in content %}{%- set content = content.split('<|think_xhigh|>') | join('') | trim %}{%- endif %}{%- if '<|think_high|>' in content %}{%- set content = content.split('<|think_high|>') | join('') | trim %}{%- endif %}{%- if '<|think_ultracode|>' in content %}{%- set content = content.split('<|think_ultracode|>') | join('') | trim %}{%- endif %}{%- if '<|think_extreme|>' in content %}{%- set content = content.split('<|think_extreme|>') | join('') | trim %}{%- endif %}{%- if '<|think_max|>' in content %}{%- set content = content.split('<|think_max|>') | join('') | trim %}{%- endif %}{%- if '<|think_medium|>' in content %}{%- set content = content.split('<|think_medium|>') | join('') | trim %}{%- endif %}{%- if '<|think_low|>' in content %}{%- set content = content.split('<|think_low|>') | join('') | trim %}{%- endif %}{%- if '<|think_minimal|>' in content %}{%- set content = content.split('<|think_minimal|>') | join('') | trim %}{%- endif %}{%- endif %}{%- if is_system %}{{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}{%- elif message.role == 'user' %}{%- set ns2.consecutive_failures = 0 %}{{- '<|im_start|>user\n' + content + '<|im_end|>\n' }}{%- elif message.role == 'assistant' %}{%- set reasoning_content = '' %}{%- if message.reasoning_content is defined and message.reasoning_content is not none %}{%- if message.reasoning_content is string %}{%- set reasoning_content = message.reasoning_content %}{%- else %}{%- set reasoning_content = message.reasoning_content | string %}{%- endif %}{%- elif message.thinking is defined and message.thinking is not none %}{%- if message.thinking is string %}{%- set reasoning_content = message.thinking %}{%- else %}{%- set reasoning_content = message.thinking | string %}{%- endif %}{%- else %}{%- set _think_end = '' %}{%- if content.startswith('</think>') %}{%- set _think_end = '</think>' %}{%- elif content.startswith('</thinking>') %}{%- set _think_end = '</thinking>' %}{%- elif '\n</think>' in content %}{%- set _think_end = '\n</think>' %}{%- elif '\n</thinking>' in content %}{%- set _think_end = '\n</thinking>' %}{%- elif '\n</ think>' in content %}{%- set _think_end = '\n</ think>' %}{%- elif '\n</think >' in content %}{%- set _think_end = '\n</think >' %}{%- endif %}{%- if _think_end %}{%- if 'thinking' in _think_end %}{%- set _think_start = '<thinking>' %}{%- else %}{%- set _think_start = '<think>' %}{%- endif %}{%- set reasoning_content = content.split(_think_end)[0].rstrip('\n') %}{%- if _think_start in reasoning_content %}{%- set reasoning_content = reasoning_content.split(_think_start)[-1].lstrip('\n') %}{%- endif %}{%- set content = content.split(_think_end)[-1].lstrip('\n') %}{%- endif %}{%- endif %}{%- set reasoning_content = reasoning_content | trim %}{%- if (_preserve_thinking or loop.index0 > ns.last_query_index) and reasoning_content %}{{- '<|im_start|>assistant\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}{%- else %}{{- '<|im_start|>assistant\n' + content }}{%- endif %}{%- if message.tool_calls is defined and message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}{%- for tool_call in message.tool_calls %}{%- if tool_call.function is defined and tool_call.function is not none %}{%- set tc = tool_call.function %}{%- else %}{%- set tc = tool_call %}{%- endif %}{%- set tc_name = tc.name if (tc.name is defined and tc.name is not none) else '' %}{%- if _tool_format == 'json' %}{%- if not loop.first or content | trim %}{{- '\n\n' }}{%- endif %}{%- set _args = '{}' %}{%- if tc.arguments is defined and tc.arguments is not none %}{%- if tc.arguments is mapping %}{%- set _args = tc.arguments | tojson %}{%- elif tc.arguments is string and tc.arguments %}{%- set _args = tc.arguments %}{%- endif %}{%- endif %}{{- '<tool_call>\n{"name": ' }}{{- tc_name | tojson }}{{- ', "arguments": ' }}{{- _args }}{{- '}\n</tool_call>' }}{%- else %}{%- if loop.first %}{%- if content | trim %}{{- '\n\n<tool_call>\n<function=' + tc_name + '>\n' }}{%- else %}{{- '<tool_call>\n<function=' + tc_name + '>\n' }}{%- endif %}{%- else %}{{- '\n\n<tool_call>\n<function=' + tc_name + '>\n' }}{%- endif %}{%- if tc.arguments is defined and tc.arguments is not none %}{%- if tc.arguments is mapping %}{%- for args_name, args_value in tc.arguments.items() %}{{- '<parameter=' + args_name + '>\n' }}{%- if args_value is string %}{%- set _av = args_value %}{%- else %}{%- set _av = args_value | tojson %}{%- endif %}{%- if max_tool_arg_chars > 0 and _av | length > max_tool_arg_chars %}{{- _av[:max_tool_arg_chars] + '\n[TRUNCATED - original length ' ~ (_av | length | string) ~ ' chars]' }}{%- else %}{{- _av }}{%- endif %}{{- '\n</parameter>\n' }}{%- endfor %}{%- elif tc.arguments is string and tc.arguments %}{{- tc.arguments }}{%- endif %}{%- endif %}{{- '</function>\n</tool_call>' }}{%- endif %}{%- endfor %}{%- endif %}{{- '<|im_end|>\n' }}{%- elif message.role == 'tool' %}{%- set _content_lower = content | lower %}{%- set _content_head = _content_lower[:120] %}{%- set _is_code_or_grep = ('throw new ' in _content_lower or 'throw error' in _content_lower or 'console.error' in _content_lower or 'logger.error' in _content_lower or 'logging.error' in _content_lower or 'import ' in _content_head or 'def ' in _content_head or 'function ' in _content_head) %}{%- if not _is_code_or_grep and content | length < 600 and '$ ' not in content and 'took ' not in _content_lower and ('"error":' in _content_head or '"status": "error"' in _content_head or '"status":"error"' in _content_head or 'error:' in _content_head or 'err!' in _content_head or 'fatal:' in _content_head or 'traceback (most recent call last):' in _content_head or 'command not found' in _content_head or 'invalid syntax' in _content_head or _content_head.startswith('exception:') or _content_head.startswith('failed to ') or 'exit code: ' in _content_head or 'process exited with code' in _content_head) %}{%- set ns2.consecutive_failures = ns2.consecutive_failures + 1 %}{%- else %}{%- set ns2.consecutive_failures = 0 %}{%- endif %}{%- if ns2.prev_role != 'tool' %}{{- '<|im_start|>user' }}{%- endif %}{%- if max_tool_response_chars > 0 and content | length > max_tool_response_chars %}{%- set content = content[:max_tool_response_chars] + '\n[TRUNCATED - original length ' ~ (content | length | string) ~ ' chars]' %}{%- endif %}{{- '\n<tool_response>\n' + content }}{%- if ns2.consecutive_failures >= 2 %}{{- '\n\n⚠️ SYSTEM WARNING: ' ~ ns2.consecutive_failures ~ ' consecutive tool errors detected. Your previous approach is incorrect. You MUST use a fundamentally different approach or corrected arguments.' }}{%- elif ns2.consecutive_failures == 1 %}{{- '\n\n⚠️ SYSTEM WARNING: The previous tool call returned an error. Diagnose the failure and retry with completely corrected arguments.' }}{%- endif %}{{- '\n</tool_response>' }}{%- if loop.last %}{{- '<|im_end|>\n' }}{%- else %}{%- set _next_role = _msgs[loop.index0 + 1].role %}{%- if _next_role != 'tool' %}{{- '<|im_end|>\n' }}{%- endif %}{%- endif %}{%- else %}{{- '<|im_start|>user\n[' + message.role + ']: ' + content + '<|im_end|>\n' }}{%- endif %}{%- set ns2.prev_role = message.role %}{%- endfor %}{%- if add_generation_prompt %}{{- '<|im_start|>assistant\n' }}{%- if not ns_state.thinking %}{{- '<think>\n\n</think>\n\n' }}{%- else %}{{- '<think>\n' }}{%- endif %}{%- endif %}

archive/v22.3_chat_template.jinja

@@ -1,421 +0,0 @@
-{%- set template_version = "qwen3.8-froggeric-v22.3" %}
-{%- set _tool_format = tool_call_format if tool_call_format is defined else 'xml' %}
-{%- set image_count = namespace(value=0) %}
-{%- set video_count = namespace(value=0) %}
-{%- set add_vision_id = add_vision_id if add_vision_id is defined else false %}
-{%- set enable_thinking = enable_thinking if enable_thinking is defined else true %}
-{%- set auto_disable_thinking_with_tools = auto_disable_thinking_with_tools if auto_disable_thinking_with_tools is defined else false %}
-{%- if preserve_reasoning is defined and preserve_reasoning is not none %}
-    {%- set _preserve_thinking = preserve_reasoning %}
-{%- elif preserve_thinking is defined and preserve_thinking is not none %}
-    {%- set _preserve_thinking = preserve_thinking %}
-{%- else %}
-    {%- set _preserve_thinking = true %}
-{%- endif %}
-{%- set max_tool_arg_chars = max_tool_arg_chars if max_tool_arg_chars is defined else 0 %}
-{%- set max_tool_response_chars = max_tool_response_chars if max_tool_response_chars is defined else 0 %}
-{%- set _has_tools = (tools is defined and tools and tools is iterable and tools is not mapping) %}
-{%- set _effort_raw = (reasoning_effort | string | lower) if reasoning_effort is defined and reasoning_effort is not none else 'medium' %}
-{%- set _initial_thinking = enable_thinking %}
-{%- set _initial_effort = 'medium' %}
-{%- if _effort_raw in ('none', 'off') %}
-    {%- set _initial_thinking = false %}
-    {%- set _initial_effort = 'medium' %}
-{%- elif _effort_raw in ('minimal', 'low') %}
-    {%- set _initial_effort = 'low' %}
-{%- elif _effort_raw in ('high', 'xhigh', 'max', 'ultracode', 'extreme') %}
-    {%- set _initial_effort = 'xhigh' %}
-{%- else %}
-    {%- set _initial_effort = 'medium' %}
-{%- endif %}
-{%- set ns_state = namespace(thinking=_initial_thinking, effort=_initial_effort) %}
-{%- if auto_disable_thinking_with_tools and _has_tools %}
-    {%- set ns_state.thinking = false %}
-{%- endif %}
-{%- for msg in messages %}
-    {%- if msg.role == 'system' or msg.role == 'developer' or msg.role == 'user' %}
-        {%- if msg.content is string %}
-            {%- if '<|think_off|>' in msg.content %}
-                {%- set ns_state.thinking = false %}
-            {%- elif '<|think_on|>' in msg.content %}
-                {%- set ns_state.thinking = true %}
-            {%- elif '<|think_xhigh|>' in msg.content or '<|think_high|>' in msg.content or '<|think_ultracode|>' in msg.content or '<|think_extreme|>' in msg.content or '<|think_max|>' in msg.content %}
-                {%- set ns_state.thinking = true %}
-                {%- set ns_state.effort = 'xhigh' %}
-            {%- elif '<|think_low|>' in msg.content or '<|think_minimal|>' in msg.content %}
-                {%- set ns_state.thinking = true %}
-                {%- set ns_state.effort = 'low' %}
-            {%- elif '<|think_medium|>' in msg.content %}
-                {%- set ns_state.thinking = true %}
-                {%- set ns_state.effort = 'medium' %}
-            {%- endif %}
-        {%- elif msg.content is iterable and msg.content is not mapping %}
-            {%- for item in msg.content %}
-                {%- if item is string %}
-                    {%- set _item_text = item %}
-                {%- elif item is mapping and 'text' in item and item.text is string %}
-                    {%- set _item_text = item.text %}
-                {%- else %}
-                    {%- set _item_text = '' %}
-                {%- endif %}
-                {%- if _item_text %}
-                    {%- if '<|think_off|>' in _item_text %}
-                        {%- set ns_state.thinking = false %}
-                    {%- elif '<|think_on|>' in _item_text %}
-                        {%- set ns_state.thinking = true %}
-                    {%- elif '<|think_xhigh|>' in _item_text or '<|think_high|>' in _item_text or '<|think_ultracode|>' in _item_text or '<|think_extreme|>' in _item_text or '<|think_max|>' in _item_text %}
-                        {%- set ns_state.thinking = true %}
-                        {%- set ns_state.effort = 'xhigh' %}
-                    {%- elif '<|think_low|>' in _item_text or '<|think_minimal|>' in _item_text %}
-                        {%- set ns_state.thinking = true %}
-                        {%- set ns_state.effort = 'low' %}
-                    {%- elif '<|think_medium|>' in _item_text %}
-                        {%- set ns_state.thinking = true %}
-                        {%- set ns_state.effort = 'medium' %}
-                    {%- endif %}
-                {%- endif %}
-            {%- endfor %}
-        {%- endif %}
-    {%- endif %}
-{%- endfor %}
-{%- set reasoning_instructions = '' %}
-{%- if ns_state.thinking %}
-    {%- if ns_state.effort == 'xhigh' %}
-        {%- set reasoning_instructions = 'Reasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.' %}
-    {%- elif ns_state.effort == 'low' %}
-        {%- set reasoning_instructions = 'Reasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration.' %}
-    {%- endif %}
-{%- endif %}
-{%- macro render_content(content, do_vision_count, is_system_content=false) %}
-    {%- if content is string %}
-        {{- content }}
-    {%- elif content is iterable and content is not mapping %}
-        {%- for item in content %}
-            {%- if item is mapping %}
-                {%- if item.type == 'image' or 'image' in item or 'image_url' in item %}
-                    {%- if is_system_content %}
-                        {{- raise_exception('System message cannot contain images.') }}
-                    {%- endif %}
-                    {%- if do_vision_count %}
-                        {%- set image_count.value = image_count.value + 1 %}
-                    {%- endif %}
-                    {%- if add_vision_id %}
-                        {{- 'Picture ' ~ image_count.value ~ ': ' }}
-                    {%- endif %}
-                    {{- '<|vision_start|><|image_pad|><|vision_end|>' }}
-                {%- elif item.type == 'video' or 'video' in item %}
-                    {%- if is_system_content %}
-                        {{- raise_exception('System message cannot contain videos.') }}
-                    {%- endif %}
-                    {%- if do_vision_count %}
-                        {%- set video_count.value = video_count.value + 1 %}
-                    {%- endif %}
-                    {%- if add_vision_id %}
-                        {{- 'Video ' ~ video_count.value ~ ': ' }}
-                    {%- endif %}
-                    {{- '<|vision_start|><|video_pad|><|vision_end|>' }}
-                {%- elif 'text' in item %}
-                    {{- item.text }}
-                {%- else %}
-                    {{- raise_exception('Unexpected item type in content.') }}
-                {%- endif %}
-            {%- else %}
-                {{- item | string }}
-            {%- endif %}
-        {%- endfor %}
-    {%- elif content is none or content is undefined %}
-        {{- '' }}
-    {%- else %}
-        {{- raise_exception('Unexpected content type.') }}
-    {%- endif %}
-{%- endmacro %}
-{%- if not messages %}
-    {{- raise_exception('No messages provided.') }}
-{%- endif %}
-{%- set head = namespace(count=0, seen_non_system=false) %}
-{%- for message in messages %}
-    {%- set _is_sys = (message.role == 'system' or message.role == 'developer') %}
-    {%- if _is_sys and not head.seen_non_system %}
-        {%- set head.count = head.count + 1 %}
-    {%- else %}
-        {%- set head.seen_non_system = true %}
-    {%- endif %}
-{%- endfor %}
-{%- set sys_state = namespace(content='') %}
-{%- for message in messages[:head.count] %}
-    {%- set _part = render_content(message.content, false, true) | trim %}
-    {%- if '<|think_off|>' in _part %}{%- set _part = _part.split('<|think_off|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_on|>' in _part %}{%- set _part = _part.split('<|think_on|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_xhigh|>' in _part %}{%- set _part = _part.split('<|think_xhigh|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_high|>' in _part %}{%- set _part = _part.split('<|think_high|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_ultracode|>' in _part %}{%- set _part = _part.split('<|think_ultracode|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_extreme|>' in _part %}{%- set _part = _part.split('<|think_extreme|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_max|>' in _part %}{%- set _part = _part.split('<|think_max|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_medium|>' in _part %}{%- set _part = _part.split('<|think_medium|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_low|>' in _part %}{%- set _part = _part.split('<|think_low|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_minimal|>' in _part %}{%- set _part = _part.split('<|think_minimal|>') | join('') | trim %}{%- endif %}
-    {%- if _part %}
-        {%- if sys_state.content %}
-            {%- set sys_state.content = sys_state.content ~ '\n\n' ~ _part %}
-        {%- else %}
-            {%- set sys_state.content = _part %}
-        {%- endif %}
-    {%- endif %}
-{%- endfor %}
-{%- set _sc = sys_state.content %}
-{%- set _msgs = messages[head.count:] %}
-{%- if _has_tools %}
-    {{- '<|im_start|>system\n' }}
-    {%- if reasoning_instructions %}
-        {{- reasoning_instructions + '\n\n' }}
-    {%- endif %}
-    {{- '# Tools\n\nYou have access to the following functions:\n\n<tools>' }}
-    {%- for tool in tools %}
-        {{- '\n' }}
-        {{- tool | tojson }}
-    {%- endfor %}
-    {{- '\n</tools>' }}
-    {%- if _tool_format == 'json' %}
-        {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<think>\nBrief explanation of tool call\n</think>\n<tool_call>\n{"name": "example_function_name", "arguments": {"example_parameter_1": "value_1", "example_parameter_2": "This is the value for the second parameter"}}\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user.\n- ALL explanation and reasoning MUST be placed strictly inside the <think></think> block.\n- Function calls MUST follow the specified format: a single JSON object with "name" and "arguments" keys inside <tool_call></tool_call> XML tags.\n- If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after thinking, with NO conversational text before it.\n- The <tool_call> tag MUST be at the very beginning of a new line, with NO spaces or indentation before it.\n- To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks.\n- If you have all necessary data, provide your final answer directly to the user without any tool call.\n</IMPORTANT>' }}
-    {%- else %}
-        {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<think>\nBrief explanation of tool call\n</think>\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user.\n- ALL explanation and reasoning MUST be placed strictly inside the <think></think> block.\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags.\n- If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after thinking, with NO conversational text before it.\n- The <tool_call> and <function> tags MUST be at the very beginning of a new line, with NO spaces or indentation before them.\n- To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks.\n- If you have all necessary data, provide your final answer directly to the user without any tool call.\n</IMPORTANT>' }}
-    {%- endif %}
-    {%- if _sc %}
-        {{- '\n\n' + _sc }}
-    {%- endif %}
-    {{- '<|im_end|>\n' }}
-{%- else %}
-    {%- if _sc %}
-        {{- '<|im_start|>system\n' + (reasoning_instructions + '\n\n' if reasoning_instructions else '') + _sc + '<|im_end|>\n' }}
-    {%- elif reasoning_instructions %}
-        {{- '<|im_start|>system\n' + reasoning_instructions + '<|im_end|>\n' }}
-    {%- endif %}
-{%- endif %}
-{%- set _last_idx = _msgs | length - 1 %}
-{%- set ns = namespace(multi_step_tool=true, last_query_index=_last_idx) %}
-{%- for message in _msgs[::-1] %}
-    {%- set index = (_msgs | length - 1) - loop.index0 %}
-    {%- if ns.multi_step_tool and message.role == 'user' %}
-        {%- set _rc = render_content(message.content, false) | trim %}
-        {%- if not (_rc.startswith('<tool_response>') and _rc.endswith('</tool_response>')) %}
-            {%- set ns.multi_step_tool = false %}
-            {%- set ns.last_query_index = index %}
-        {%- endif %}
-    {%- endif %}
-{%- endfor %}
-{%- if ns.multi_step_tool %}
-    {%- if _last_idx > 50 %}
-        {%- set ns.last_query_index = _last_idx %}
-    {%- else %}
-        {%- set ns.last_query_index = 0 %}
-    {%- endif %}
-{%- endif %}
-{%- set ns2 = namespace(prev_role='', consecutive_failures=0) %}
-{%- for message in _msgs %}
-    {%- set is_system = (message.role == "system" or message.role == "developer") %}
-    {%- set content = render_content(message.content, true, is_system) | trim %}
-    {%- if is_system or message.role == 'user' %}
-        {%- if '<|think_off|>' in content %}{%- set content = content.split('<|think_off|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_on|>' in content %}{%- set content = content.split('<|think_on|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_xhigh|>' in content %}{%- set content = content.split('<|think_xhigh|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_high|>' in content %}{%- set content = content.split('<|think_high|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_ultracode|>' in content %}{%- set content = content.split('<|think_ultracode|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_extreme|>' in content %}{%- set content = content.split('<|think_extreme|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_max|>' in content %}{%- set content = content.split('<|think_max|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_medium|>' in content %}{%- set content = content.split('<|think_medium|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_low|>' in content %}{%- set content = content.split('<|think_low|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_minimal|>' in content %}{%- set content = content.split('<|think_minimal|>') | join('') | trim %}{%- endif %}
-    {%- endif %}
-    {%- if is_system %}
-        {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}
-    {%- elif message.role == 'user' %}
-        {%- set ns2.consecutive_failures = 0 %}
-        {{- '<|im_start|>user\n' + content + '<|im_end|>\n' }}
-    {%- elif message.role == 'assistant' %}
-        {%- set reasoning_content = '' %}
-        {%- set _explicit_reasoning = '' %}
-        {%- if message.reasoning_content is defined and message.reasoning_content is not none %}
-            {%- if message.reasoning_content is string %}
-                {%- set _explicit_reasoning = message.reasoning_content %}
-            {%- else %}
-                {%- set _explicit_reasoning = message.reasoning_content | string %}
-            {%- endif %}
-        {%- elif message.thinking is defined and message.thinking is not none %}
-            {%- if message.thinking is string %}
-                {%- set _explicit_reasoning = message.thinking %}
-            {%- else %}
-                {%- set _explicit_reasoning = message.thinking | string %}
-            {%- endif %}
-        {%- endif %}
-        {%- if _explicit_reasoning %}
-            {%- set _lead_end = '' %}
-            {%- if content.startswith('<think>') and '</think>' in content %}
-                {%- set _lead_end = '</think>' %}
-            {%- elif content.startswith('<thinking>') and '</thinking>' in content %}
-                {%- set _lead_end = '</thinking>' %}
-            {%- elif content.startswith('</think>') %}
-                {%- set _lead_end = '</think>' %}
-            {%- elif content.startswith('</thinking>') %}
-                {%- set _lead_end = '</thinking>' %}
-            {%- endif %}
-            {%- if _lead_end %}
-                {%- set content = content.split(_lead_end)[-1].lstrip('\n') %}
-            {%- endif %}
-            {%- set reasoning_content = _explicit_reasoning %}
-        {%- else %}
-            {%- set _think_end = '' %}
-            {%- if content.startswith('</think>') %}
-                {%- set _think_end = '</think>' %}
-            {%- elif content.startswith('</thinking>') %}
-                {%- set _think_end = '</thinking>' %}
-            {%- elif '\n</think>' in content %}
-                {%- set _think_end = '\n</think>' %}
-            {%- elif '\n</thinking>' in content %}
-                {%- set _think_end = '\n</thinking>' %}
-            {%- elif '\n</ think>' in content %}
-                {%- set _think_end = '\n</ think>' %}
-            {%- elif '\n</think >' in content %}
-                {%- set _think_end = '\n</think >' %}
-            {%- elif content.startswith('<think>') and '</think>' in content %}
-                {%- set _think_end = '</think>' %}
-            {%- elif content.startswith('<thinking>') and '</thinking>' in content %}
-                {%- set _think_end = '</thinking>' %}
-            {%- endif %}
-            {%- if _think_end %}
-                {%- if 'thinking' in _think_end %}
-                    {%- set _think_start = '<thinking>' %}
-                {%- else %}
-                    {%- set _think_start = '<think>' %}
-                {%- endif %}
-                {%- set reasoning_content = content.split(_think_end)[0].rstrip('\n') %}
-                {%- if _think_start in reasoning_content %}
-                    {%- set reasoning_content = reasoning_content.split(_think_start)[-1].lstrip('\n') %}
-                {%- endif %}
-                {%- set content = content.split(_think_end)[-1].lstrip('\n') %}
-            {%- endif %}
-        {%- endif %}
-        {%- set reasoning_content = reasoning_content | trim %}
-        {%- if (_preserve_thinking or loop.index0 > ns.last_query_index) %}
-            {{- '<|im_start|>assistant\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}
-        {%- else %}
-            {{- '<|im_start|>assistant\n' + content }}
-        {%- endif %}
-        {%- if message.tool_calls is defined and message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}
-            {%- for tool_call in message.tool_calls %}
-                {%- if tool_call.function is defined and tool_call.function is not none %}
-                    {%- set tc = tool_call.function %}
-                {%- else %}
-                    {%- set tc = tool_call %}
-                {%- endif %}
-                {%- set tc_name = tc.name if (tc.name is defined and tc.name is not none) else '' %}
-                {%- if _tool_format == 'json' %}
-                    {%- if not loop.first or content | trim %}
-                        {{- '\n\n' }}
-                    {%- endif %}
-                    {%- set _args = '{}' %}
-                    {%- if tc.arguments is defined and tc.arguments is not none %}
-                        {%- if tc.arguments is mapping %}
-                            {%- set _args = tc.arguments | tojson %}
-                        {%- elif tc.arguments is string %}
-                            {%- if tc.arguments %}
-                                {%- set _args = tc.arguments %}
-                            {%- endif %}
-                        {%- else %}
-                            {%- set _args = tc.arguments | tojson %}
-                        {%- endif %}
-                    {%- endif %}
-                    {{- '<tool_call>\n{"name": ' }}{{- tc_name | tojson }}{{- ', "arguments": ' }}{{- _args }}{{- '}\n</tool_call>' }}
-                {%- else %}
-                    {%- if loop.first %}
-                        {%- if content | trim %}
-                            {{- '\n\n<tool_call>\n<function=' + tc_name + '>\n' }}
-                        {%- else %}
-                            {{- '<tool_call>\n<function=' + tc_name + '>\n' }}
-                        {%- endif %}
-                    {%- else %}
-                        {{- '\n\n<tool_call>\n<function=' + tc_name + '>\n' }}
-                    {%- endif %}
-                    {%- if tc.arguments is defined and tc.arguments is not none %}
-                        {%- if tc.arguments is mapping %}
-                            {%- for args_name, args_value in tc.arguments.items() %}
-                                {{- '<parameter=' + args_name + '>\n' }}
-                                {%- if args_value is string %}
-                                    {%- set _av = args_value %}
-                                {%- else %}
-                                    {%- set _av = args_value | tojson %}
-                                {%- endif %}
-                                {%- if max_tool_arg_chars > 0 and _av | length > max_tool_arg_chars %}
-                                    {{- _av[:max_tool_arg_chars] + '\n[TRUNCATED - original length ' ~ (_av | length | string) ~ ' chars]' }}
-                                {%- else %}
-                                    {{- _av }}
-                                {%- endif %}
-                                {{- '\n</parameter>\n' }}
-                            {%- endfor %}
-                        {%- else %}
-                            {%- if tc.arguments is string %}
-                                {%- set _raw_args = tc.arguments %}
-                            {%- else %}
-                                {%- set _raw_args = tc.arguments | tojson %}
-                            {%- endif %}
-                            {%- if _raw_args %}
-                                {%- if max_tool_arg_chars > 0 and _raw_args | length > max_tool_arg_chars %}
-                                    {{- _raw_args[:max_tool_arg_chars] + '\n[TRUNCATED - original length ' ~ (_raw_args | length | string) ~ ' chars]' }}
-                                {%- else %}
-                                    {{- _raw_args }}
-                                {%- endif %}
-                            {%- endif %}
-                        {%- endif %}
-                    {%- endif %}
-                    {{- '</function>\n</tool_call>' }}
-                {%- endif %}
-            {%- endfor %}
-        {%- endif %}
-        {{- '<|im_end|>\n' }}
-    {%- elif message.role == 'tool' %}
-        {%- set _content_lower = content | lower %}
-        {%- set _content_head = _content_lower[:120] %}
-        {%- set _is_code_or_grep = ('throw new ' in _content_lower or 'throw error' in _content_lower or 'console.error' in _content_lower or 'logger.error' in _content_lower or 'logging.error' in _content_lower or 'import ' in _content_head or 'def ' in _content_head or 'function ' in _content_head) %}
-        {%- set _exit_code_zero = ('exit code: 0' in _content_head or 'process exited with code 0' in _content_head) %}
-        {%- set _error_field_ok = ('"error": null' in _content_head or '"error":null' in _content_head or '"error": false' in _content_head or '"error":false' in _content_head or '"error": ""' in _content_head or '"error":""' in _content_head) %}
-        {%- set _strong_error = (('"error":' in _content_head and not _error_field_ok) or '"status": "error"' in _content_head or '"status":"error"' in _content_head or 'traceback (most recent call last):' in _content_head or 'command not found' in _content_head or 'invalid syntax' in _content_head or 'fatal:' in _content_head or (('exit code: ' in _content_head or 'process exited with code' in _content_head) and not _exit_code_zero) or _content_head.startswith('exception:') or _content_head.startswith('failed to ')) %}
-        {%- set _weak_error = ('error:' in _content_head or 'err!' in _content_head) %}
-        {%- set _weak_suppressed = ('$ ' in _content_head or 'took ' in _content_head or content | length >= 600) %}
-        {%- if not _is_code_or_grep and (_strong_error or (_weak_error and not _weak_suppressed)) %}
-            {%- set ns2.consecutive_failures = ns2.consecutive_failures + 1 %}
-        {%- else %}
-            {%- set ns2.consecutive_failures = 0 %}
-        {%- endif %}
-        {%- if ns2.prev_role != 'tool' %}
-            {{- '<|im_start|>user' }}
-        {%- endif %}
-        {%- if _tool_format != 'json' and max_tool_response_chars > 0 and content | length > max_tool_response_chars %}
-            {%- set content = content[:max_tool_response_chars] + '\n[TRUNCATED - original length ' ~ (content | length | string) ~ ' chars]' %}
-        {%- endif %}
-        {{- '\n<tool_response>\n' + content }}
-        {%- if ns2.consecutive_failures >= 2 %}
-            {{- '\n\n⚠️ SYSTEM WARNING: ' ~ ns2.consecutive_failures ~ ' consecutive tool errors detected. Your previous approach is incorrect. You MUST use a fundamentally different approach or corrected arguments.' }}
-        {%- elif ns2.consecutive_failures == 1 %}
-            {{- '\n\n⚠️ SYSTEM WARNING: The previous tool call returned an error. Diagnose the failure and retry with completely corrected arguments.' }}
-        {%- endif %}
-        {{- '\n</tool_response>' }}
-        {%- if loop.last %}
-            {{- '<|im_end|>\n' }}
-        {%- else %}
-            {%- set _next_role = _msgs[loop.index0 + 1].role %}
-            {%- if _next_role != 'tool' %}
-                {{- '<|im_end|>\n' }}
-            {%- endif %}
-        {%- endif %}
-    {%- else %}
-        {{- '<|im_start|>user\n[' + message.role + ']: ' + content + '<|im_end|>\n' }}
-    {%- endif %}
-    {%- set ns2.prev_role = message.role %}
-{%- endfor %}
-{%- if add_generation_prompt %}
-    {{- '<|im_start|>assistant\n' }}
-    {%- if not ns_state.thinking %}
-        {{- '<think>\n\n</think>\n\n' }}
-    {%- else %}
-        {{- '<think>\n' }}
-    {%- endif %}
-{%- endif %}

archive/v22.3_chat_template_oneline.txt

@@ -1 +0,0 @@
-{%- set template_version = "qwen3.8-froggeric-v22.3" %}{%- set _tool_format = tool_call_format if tool_call_format is defined else 'xml' %}{%- set image_count = namespace(value=0) %}{%- set video_count = namespace(value=0) %}{%- set add_vision_id = add_vision_id if add_vision_id is defined else false %}{%- set enable_thinking = enable_thinking if enable_thinking is defined else true %}{%- set auto_disable_thinking_with_tools = auto_disable_thinking_with_tools if auto_disable_thinking_with_tools is defined else false %}{%- if preserve_reasoning is defined and preserve_reasoning is not none %}{%- set _preserve_thinking = preserve_reasoning %}{%- elif preserve_thinking is defined and preserve_thinking is not none %}{%- set _preserve_thinking = preserve_thinking %}{%- else %}{%- set _preserve_thinking = true %}{%- endif %}{%- set max_tool_arg_chars = max_tool_arg_chars if max_tool_arg_chars is defined else 0 %}{%- set max_tool_response_chars = max_tool_response_chars if max_tool_response_chars is defined else 0 %}{%- set _has_tools = (tools is defined and tools and tools is iterable and tools is not mapping) %}{%- set _effort_raw = (reasoning_effort | string | lower) if reasoning_effort is defined and reasoning_effort is not none else 'medium' %}{%- set _initial_thinking = enable_thinking %}{%- set _initial_effort = 'medium' %}{%- if _effort_raw in ('none', 'off') %}{%- set _initial_thinking = false %}{%- set _initial_effort = 'medium' %}{%- elif _effort_raw in ('minimal', 'low') %}{%- set _initial_effort = 'low' %}{%- elif _effort_raw in ('high', 'xhigh', 'max', 'ultracode', 'extreme') %}{%- set _initial_effort = 'xhigh' %}{%- else %}{%- set _initial_effort = 'medium' %}{%- endif %}{%- set ns_state = namespace(thinking=_initial_thinking, effort=_initial_effort) %}{%- if auto_disable_thinking_with_tools and _has_tools %}{%- set ns_state.thinking = false %}{%- endif %}{%- for msg in messages %}{%- if msg.role == 'system' or msg.role == 'developer' or msg.role == 'user' %}{%- if msg.content is string %}{%- if '<|think_off|>' in msg.content %}{%- set ns_state.thinking = false %}{%- elif '<|think_on|>' in msg.content %}{%- set ns_state.thinking = true %}{%- elif '<|think_xhigh|>' in msg.content or '<|think_high|>' in msg.content or '<|think_ultracode|>' in msg.content or '<|think_extreme|>' in msg.content or '<|think_max|>' in msg.content %}{%- set ns_state.thinking = true %}{%- set ns_state.effort = 'xhigh' %}{%- elif '<|think_low|>' in msg.content or '<|think_minimal|>' in msg.content %}{%- set ns_state.thinking = true %}{%- set ns_state.effort = 'low' %}{%- elif '<|think_medium|>' in msg.content %}{%- set ns_state.thinking = true %}{%- set ns_state.effort = 'medium' %}{%- endif %}{%- elif msg.content is iterable and msg.content is not mapping %}{%- for item in msg.content %}{%- if item is string %}{%- set _item_text = item %}{%- elif item is mapping and 'text' in item and item.text is string %}{%- set _item_text = item.text %}{%- else %}{%- set _item_text = '' %}{%- endif %}{%- if _item_text %}{%- if '<|think_off|>' in _item_text %}{%- set ns_state.thinking = false %}{%- elif '<|think_on|>' in _item_text %}{%- set ns_state.thinking = true %}{%- elif '<|think_xhigh|>' in _item_text or '<|think_high|>' in _item_text or '<|think_ultracode|>' in _item_text or '<|think_extreme|>' in _item_text or '<|think_max|>' in _item_text %}{%- set ns_state.thinking = true %}{%- set ns_state.effort = 'xhigh' %}{%- elif '<|think_low|>' in _item_text or '<|think_minimal|>' in _item_text %}{%- set ns_state.thinking = true %}{%- set ns_state.effort = 'low' %}{%- elif '<|think_medium|>' in _item_text %}{%- set ns_state.thinking = true %}{%- set ns_state.effort = 'medium' %}{%- endif %}{%- endif %}{%- endfor %}{%- endif %}{%- endif %}{%- endfor %}{%- set reasoning_instructions = '' %}{%- if ns_state.thinking %}{%- if ns_state.effort == 'xhigh' %}{%- set reasoning_instructions = 'Reasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.' %}{%- elif ns_state.effort == 'low' %}{%- set reasoning_instructions = 'Reasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration.' %}{%- endif %}{%- endif %}{%- macro render_content(content, do_vision_count, is_system_content=false) %}{%- if content is string %}{{- content }}{%- elif content is iterable and content is not mapping %}{%- for item in content %}{%- if item is mapping %}{%- if item.type == 'image' or 'image' in item or 'image_url' in item %}{%- if is_system_content %}{{- raise_exception('System message cannot contain images.') }}{%- endif %}{%- if do_vision_count %}{%- set image_count.value = image_count.value + 1 %}{%- endif %}{%- if add_vision_id %}{{- 'Picture ' ~ image_count.value ~ ': ' }}{%- endif %}{{- '<|vision_start|><|image_pad|><|vision_end|>' }}{%- elif item.type == 'video' or 'video' in item %}{%- if is_system_content %}{{- raise_exception('System message cannot contain videos.') }}{%- endif %}{%- if do_vision_count %}{%- set video_count.value = video_count.value + 1 %}{%- endif %}{%- if add_vision_id %}{{- 'Video ' ~ video_count.value ~ ': ' }}{%- endif %}{{- '<|vision_start|><|video_pad|><|vision_end|>' }}{%- elif 'text' in item %}{{- item.text }}{%- else %}{{- raise_exception('Unexpected item type in content.') }}{%- endif %}{%- else %}{{- item | string }}{%- endif %}{%- endfor %}{%- elif content is none or content is undefined %}{{- '' }}{%- else %}{{- raise_exception('Unexpected content type.') }}{%- endif %}{%- endmacro %}{%- if not messages %}{{- raise_exception('No messages provided.') }}{%- endif %}{%- set head = namespace(count=0, seen_non_system=false) %}{%- for message in messages %}{%- set _is_sys = (message.role == 'system' or message.role == 'developer') %}{%- if _is_sys and not head.seen_non_system %}{%- set head.count = head.count + 1 %}{%- else %}{%- set head.seen_non_system = true %}{%- endif %}{%- endfor %}{%- set sys_state = namespace(content='') %}{%- for message in messages[:head.count] %}{%- set _part = render_content(message.content, false, true) | trim %}{%- if '<|think_off|>' in _part %}{%- set _part = _part.split('<|think_off|>') | join('') | trim %}{%- endif %}{%- if '<|think_on|>' in _part %}{%- set _part = _part.split('<|think_on|>') | join('') | trim %}{%- endif %}{%- if '<|think_xhigh|>' in _part %}{%- set _part = _part.split('<|think_xhigh|>') | join('') | trim %}{%- endif %}{%- if '<|think_high|>' in _part %}{%- set _part = _part.split('<|think_high|>') | join('') | trim %}{%- endif %}{%- if '<|think_ultracode|>' in _part %}{%- set _part = _part.split('<|think_ultracode|>') | join('') | trim %}{%- endif %}{%- if '<|think_extreme|>' in _part %}{%- set _part = _part.split('<|think_extreme|>') | join('') | trim %}{%- endif %}{%- if '<|think_max|>' in _part %}{%- set _part = _part.split('<|think_max|>') | join('') | trim %}{%- endif %}{%- if '<|think_medium|>' in _part %}{%- set _part = _part.split('<|think_medium|>') | join('') | trim %}{%- endif %}{%- if '<|think_low|>' in _part %}{%- set _part = _part.split('<|think_low|>') | join('') | trim %}{%- endif %}{%- if '<|think_minimal|>' in _part %}{%- set _part = _part.split('<|think_minimal|>') | join('') | trim %}{%- endif %}{%- if _part %}{%- if sys_state.content %}{%- set sys_state.content = sys_state.content ~ '\n\n' ~ _part %}{%- else %}{%- set sys_state.content = _part %}{%- endif %}{%- endif %}{%- endfor %}{%- set _sc = sys_state.content %}{%- set _msgs = messages[head.count:] %}{%- if _has_tools %}{{- '<|im_start|>system\n' }}{%- if reasoning_instructions %}{{- reasoning_instructions + '\n\n' }}{%- endif %}{{- '# Tools\n\nYou have access to the following functions:\n\n<tools>' }}{%- for tool in tools %}{{- '\n' }}{{- tool | tojson }}{%- endfor %}{{- '\n</tools>' }}{%- if _tool_format == 'json' %}{{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<think>\nBrief explanation of tool call\n</think>\n<tool_call>\n{"name": "example_function_name", "arguments": {"example_parameter_1": "value_1", "example_parameter_2": "This is the value for the second parameter"}}\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user.\n- ALL explanation and reasoning MUST be placed strictly inside the <think></think> block.\n- Function calls MUST follow the specified format: a single JSON object with "name" and "arguments" keys inside <tool_call></tool_call> XML tags.\n- If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after thinking, with NO conversational text before it.\n- The <tool_call> tag MUST be at the very beginning of a new line, with NO spaces or indentation before it.\n- To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks.\n- If you have all necessary data, provide your final answer directly to the user without any tool call.\n</IMPORTANT>' }}{%- else %}{{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<think>\nBrief explanation of tool call\n</think>\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user.\n- ALL explanation and reasoning MUST be placed strictly inside the <think></think> block.\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags.\n- If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after thinking, with NO conversational text before it.\n- The <tool_call> and <function> tags MUST be at the very beginning of a new line, with NO spaces or indentation before them.\n- To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks.\n- If you have all necessary data, provide your final answer directly to the user without any tool call.\n</IMPORTANT>' }}{%- endif %}{%- if _sc %}{{- '\n\n' + _sc }}{%- endif %}{{- '<|im_end|>\n' }}{%- else %}{%- if _sc %}{{- '<|im_start|>system\n' + (reasoning_instructions + '\n\n' if reasoning_instructions else '') + _sc + '<|im_end|>\n' }}{%- elif reasoning_instructions %}{{- '<|im_start|>system\n' + reasoning_instructions + '<|im_end|>\n' }}{%- endif %}{%- endif %}{%- set _last_idx = _msgs | length - 1 %}{%- set ns = namespace(multi_step_tool=true, last_query_index=_last_idx) %}{%- for message in _msgs[::-1] %}{%- set index = (_msgs | length - 1) - loop.index0 %}{%- if ns.multi_step_tool and message.role == 'user' %}{%- set _rc = render_content(message.content, false) | trim %}{%- if not (_rc.startswith('<tool_response>') and _rc.endswith('</tool_response>')) %}{%- set ns.multi_step_tool = false %}{%- set ns.last_query_index = index %}{%- endif %}{%- endif %}{%- endfor %}{%- if ns.multi_step_tool %}{%- if _last_idx > 50 %}{%- set ns.last_query_index = _last_idx %}{%- else %}{%- set ns.last_query_index = 0 %}{%- endif %}{%- endif %}{%- set ns2 = namespace(prev_role='', consecutive_failures=0) %}{%- for message in _msgs %}{%- set is_system = (message.role == "system" or message.role == "developer") %}{%- set content = render_content(message.content, true, is_system) | trim %}{%- if is_system or message.role == 'user' %}{%- if '<|think_off|>' in content %}{%- set content = content.split('<|think_off|>') | join('') | trim %}{%- endif %}{%- if '<|think_on|>' in content %}{%- set content = content.split('<|think_on|>') | join('') | trim %}{%- endif %}{%- if '<|think_xhigh|>' in content %}{%- set content = content.split('<|think_xhigh|>') | join('') | trim %}{%- endif %}{%- if '<|think_high|>' in content %}{%- set content = content.split('<|think_high|>') | join('') | trim %}{%- endif %}{%- if '<|think_ultracode|>' in content %}{%- set content = content.split('<|think_ultracode|>') | join('') | trim %}{%- endif %}{%- if '<|think_extreme|>' in content %}{%- set content = content.split('<|think_extreme|>') | join('') | trim %}{%- endif %}{%- if '<|think_max|>' in content %}{%- set content = content.split('<|think_max|>') | join('') | trim %}{%- endif %}{%- if '<|think_medium|>' in content %}{%- set content = content.split('<|think_medium|>') | join('') | trim %}{%- endif %}{%- if '<|think_low|>' in content %}{%- set content = content.split('<|think_low|>') | join('') | trim %}{%- endif %}{%- if '<|think_minimal|>' in content %}{%- set content = content.split('<|think_minimal|>') | join('') | trim %}{%- endif %}{%- endif %}{%- if is_system %}{{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}{%- elif message.role == 'user' %}{%- set ns2.consecutive_failures = 0 %}{{- '<|im_start|>user\n' + content + '<|im_end|>\n' }}{%- elif message.role == 'assistant' %}{%- set reasoning_content = '' %}{%- set _explicit_reasoning = '' %}{%- if message.reasoning_content is defined and message.reasoning_content is not none %}{%- if message.reasoning_content is string %}{%- set _explicit_reasoning = message.reasoning_content %}{%- else %}{%- set _explicit_reasoning = message.reasoning_content | string %}{%- endif %}{%- elif message.thinking is defined and message.thinking is not none %}{%- if message.thinking is string %}{%- set _explicit_reasoning = message.thinking %}{%- else %}{%- set _explicit_reasoning = message.thinking | string %}{%- endif %}{%- endif %}{%- if _explicit_reasoning %}{%- set _lead_end = '' %}{%- if content.startswith('<think>') and '</think>' in content %}{%- set _lead_end = '</think>' %}{%- elif content.startswith('<thinking>') and '</thinking>' in content %}{%- set _lead_end = '</thinking>' %}{%- elif content.startswith('</think>') %}{%- set _lead_end = '</think>' %}{%- elif content.startswith('</thinking>') %}{%- set _lead_end = '</thinking>' %}{%- endif %}{%- if _lead_end %}{%- set content = content.split(_lead_end)[-1].lstrip('\n') %}{%- endif %}{%- set reasoning_content = _explicit_reasoning %}{%- else %}{%- set _think_end = '' %}{%- if content.startswith('</think>') %}{%- set _think_end = '</think>' %}{%- elif content.startswith('</thinking>') %}{%- set _think_end = '</thinking>' %}{%- elif '\n</think>' in content %}{%- set _think_end = '\n</think>' %}{%- elif '\n</thinking>' in content %}{%- set _think_end = '\n</thinking>' %}{%- elif '\n</ think>' in content %}{%- set _think_end = '\n</ think>' %}{%- elif '\n</think >' in content %}{%- set _think_end = '\n</think >' %}{%- elif content.startswith('<think>') and '</think>' in content %}{%- set _think_end = '</think>' %}{%- elif content.startswith('<thinking>') and '</thinking>' in content %}{%- set _think_end = '</thinking>' %}{%- endif %}{%- if _think_end %}{%- if 'thinking' in _think_end %}{%- set _think_start = '<thinking>' %}{%- else %}{%- set _think_start = '<think>' %}{%- endif %}{%- set reasoning_content = content.split(_think_end)[0].rstrip('\n') %}{%- if _think_start in reasoning_content %}{%- set reasoning_content = reasoning_content.split(_think_start)[-1].lstrip('\n') %}{%- endif %}{%- set content = content.split(_think_end)[-1].lstrip('\n') %}{%- endif %}{%- endif %}{%- set reasoning_content = reasoning_content | trim %}{%- if (_preserve_thinking or loop.index0 > ns.last_query_index) %}{{- '<|im_start|>assistant\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}{%- else %}{{- '<|im_start|>assistant\n' + content }}{%- endif %}{%- if message.tool_calls is defined and message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}{%- for tool_call in message.tool_calls %}{%- if tool_call.function is defined and tool_call.function is not none %}{%- set tc = tool_call.function %}{%- else %}{%- set tc = tool_call %}{%- endif %}{%- set tc_name = tc.name if (tc.name is defined and tc.name is not none) else '' %}{%- if _tool_format == 'json' %}{%- if not loop.first or content | trim %}{{- '\n\n' }}{%- endif %}{%- set _args = '{}' %}{%- if tc.arguments is defined and tc.arguments is not none %}{%- if tc.arguments is mapping %}{%- set _args = tc.arguments | tojson %}{%- elif tc.arguments is string %}{%- if tc.arguments %}{%- set _args = tc.arguments %}{%- endif %}{%- else %}{%- set _args = tc.arguments | tojson %}{%- endif %}{%- endif %}{{- '<tool_call>\n{"name": ' }}{{- tc_name | tojson }}{{- ', "arguments": ' }}{{- _args }}{{- '}\n</tool_call>' }}{%- else %}{%- if loop.first %}{%- if content | trim %}{{- '\n\n<tool_call>\n<function=' + tc_name + '>\n' }}{%- else %}{{- '<tool_call>\n<function=' + tc_name + '>\n' }}{%- endif %}{%- else %}{{- '\n\n<tool_call>\n<function=' + tc_name + '>\n' }}{%- endif %}{%- if tc.arguments is defined and tc.arguments is not none %}{%- if tc.arguments is mapping %}{%- for args_name, args_value in tc.arguments.items() %}{{- '<parameter=' + args_name + '>\n' }}{%- if args_value is string %}{%- set _av = args_value %}{%- else %}{%- set _av = args_value | tojson %}{%- endif %}{%- if max_tool_arg_chars > 0 and _av | length > max_tool_arg_chars %}{{- _av[:max_tool_arg_chars] + '\n[TRUNCATED - original length ' ~ (_av | length | string) ~ ' chars]' }}{%- else %}{{- _av }}{%- endif %}{{- '\n</parameter>\n' }}{%- endfor %}{%- else %}{%- if tc.arguments is string %}{%- set _raw_args = tc.arguments %}{%- else %}{%- set _raw_args = tc.arguments | tojson %}{%- endif %}{%- if _raw_args %}{%- if max_tool_arg_chars > 0 and _raw_args | length > max_tool_arg_chars %}{{- _raw_args[:max_tool_arg_chars] + '\n[TRUNCATED - original length ' ~ (_raw_args | length | string) ~ ' chars]' }}{%- else %}{{- _raw_args }}{%- endif %}{%- endif %}{%- endif %}{%- endif %}{{- '</function>\n</tool_call>' }}{%- endif %}{%- endfor %}{%- endif %}{{- '<|im_end|>\n' }}{%- elif message.role == 'tool' %}{%- set _content_lower = content | lower %}{%- set _content_head = _content_lower[:120] %}{%- set _is_code_or_grep = ('throw new ' in _content_lower or 'throw error' in _content_lower or 'console.error' in _content_lower or 'logger.error' in _content_lower or 'logging.error' in _content_lower or 'import ' in _content_head or 'def ' in _content_head or 'function ' in _content_head) %}{%- set _exit_code_zero = ('exit code: 0' in _content_head or 'process exited with code 0' in _content_head) %}{%- set _error_field_ok = ('"error": null' in _content_head or '"error":null' in _content_head or '"error": false' in _content_head or '"error":false' in _content_head or '"error": ""' in _content_head or '"error":""' in _content_head) %}{%- set _strong_error = (('"error":' in _content_head and not _error_field_ok) or '"status": "error"' in _content_head or '"status":"error"' in _content_head or 'traceback (most recent call last):' in _content_head or 'command not found' in _content_head or 'invalid syntax' in _content_head or 'fatal:' in _content_head or (('exit code: ' in _content_head or 'process exited with code' in _content_head) and not _exit_code_zero) or _content_head.startswith('exception:') or _content_head.startswith('failed to ')) %}{%- set _weak_error = ('error:' in _content_head or 'err!' in _content_head) %}{%- set _weak_suppressed = ('$ ' in _content_head or 'took ' in _content_head or content | length >= 600) %}{%- if not _is_code_or_grep and (_strong_error or (_weak_error and not _weak_suppressed)) %}{%- set ns2.consecutive_failures = ns2.consecutive_failures + 1 %}{%- else %}{%- set ns2.consecutive_failures = 0 %}{%- endif %}{%- if ns2.prev_role != 'tool' %}{{- '<|im_start|>user' }}{%- endif %}{%- if _tool_format != 'json' and max_tool_response_chars > 0 and content | length > max_tool_response_chars %}{%- set content = content[:max_tool_response_chars] + '\n[TRUNCATED - original length ' ~ (content | length | string) ~ ' chars]' %}{%- endif %}{{- '\n<tool_response>\n' + content }}{%- if ns2.consecutive_failures >= 2 %}{{- '\n\n⚠️ SYSTEM WARNING: ' ~ ns2.consecutive_failures ~ ' consecutive tool errors detected. Your previous approach is incorrect. You MUST use a fundamentally different approach or corrected arguments.' }}{%- elif ns2.consecutive_failures == 1 %}{{- '\n\n⚠️ SYSTEM WARNING: The previous tool call returned an error. Diagnose the failure and retry with completely corrected arguments.' }}{%- endif %}{{- '\n</tool_response>' }}{%- if loop.last %}{{- '<|im_end|>\n' }}{%- else %}{%- set _next_role = _msgs[loop.index0 + 1].role %}{%- if _next_role != 'tool' %}{{- '<|im_end|>\n' }}{%- endif %}{%- endif %}{%- else %}{{- '<|im_start|>user\n[' + message.role + ']: ' + content + '<|im_end|>\n' }}{%- endif %}{%- set ns2.prev_role = message.role %}{%- endfor %}{%- if add_generation_prompt %}{{- '<|im_start|>assistant\n' }}{%- if not ns_state.thinking %}{{- '<think>\n\n</think>\n\n' }}{%- else %}{{- '<think>\n' }}{%- endif %}{%- endif %}

archive/v22_chat_template.jinja

@@ -1,331 +0,0 @@
-{%- set template_version = "qwen3.8-froggeric-v22" %}
-{%- set _tool_format = tool_call_format if tool_call_format is defined else 'xml' %}
-{%- set image_count = namespace(value=0) %}
-{%- set video_count = namespace(value=0) %}
-{%- set add_vision_id = add_vision_id if add_vision_id is defined else false %}
-{%- set enable_thinking = enable_thinking if enable_thinking is defined else true %}
-{%- set auto_disable_thinking_with_tools = auto_disable_thinking_with_tools if auto_disable_thinking_with_tools is defined else false %}
-{%- if preserve_reasoning is defined and preserve_reasoning is not none %}
-    {%- set _preserve_thinking = preserve_reasoning %}
-{%- elif preserve_thinking is defined and preserve_thinking is not none %}
-    {%- set _preserve_thinking = preserve_thinking %}
-{%- else %}
-    {%- set _preserve_thinking = true %}
-{%- endif %}
-{%- set max_tool_arg_chars = max_tool_arg_chars if max_tool_arg_chars is defined else 0 %}
-{%- set max_tool_response_chars = max_tool_response_chars if max_tool_response_chars is defined else 0 %}
-{%- set _has_tools = (tools is defined and tools and tools is iterable and tools is not mapping) %}
-{%- set ns_state = namespace(thinking=enable_thinking) %}
-{%- if auto_disable_thinking_with_tools and _has_tools %}
-    {%- set ns_state.thinking = false %}
-{%- endif %}
-{%- for msg in messages %}
-    {%- if msg.role == 'system' or msg.role == 'developer' or msg.role == 'user' %}
-        {%- if msg.content is string %}
-            {%- if '<|think_off|>' in msg.content %}
-                {%- set ns_state.thinking = false %}
-            {%- elif '<|think_on|>' in msg.content %}
-                {%- set ns_state.thinking = true %}
-            {%- endif %}
-        {%- elif msg.content is iterable and msg.content is not mapping %}
-            {%- for item in msg.content %}
-                {%- if item is mapping and 'text' in item and item.text is string %}
-                    {%- if '<|think_off|>' in item.text %}
-                        {%- set ns_state.thinking = false %}
-                    {%- elif '<|think_on|>' in item.text %}
-                        {%- set ns_state.thinking = true %}
-                    {%- endif %}
-                {%- endif %}
-            {%- endfor %}
-        {%- endif %}
-    {%- endif %}
-{%- endfor %}
-{%- set _effort_raw = reasoning_effort if reasoning_effort is defined else 'xhigh' %}
-{%- if _effort_raw == 'high' or _effort_raw == 'xhigh' %}
-    {%- set _reasoning_effort = 'xhigh' %}
-{%- elif _effort_raw == 'low' %}
-    {%- set _reasoning_effort = 'low' %}
-{%- elif _effort_raw == 'medium' %}
-    {%- set _reasoning_effort = 'medium' %}
-{%- else %}
-    {%- set _reasoning_effort = 'xhigh' %}
-{%- endif %}
-{%- set reasoning_instructions = '' %}
-{%- if ns_state.thinking %}
-    {%- if _reasoning_effort == 'xhigh' %}
-        {%- set reasoning_instructions = 'Reasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.' %}
-    {%- elif _reasoning_effort == 'low' %}
-        {%- set reasoning_instructions = 'Reasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration.' %}
-    {%- endif %}
-{%- endif %}
-{%- macro render_content(content, do_vision_count, is_system_content=false) %}
-    {%- if content is string %}
-        {{- content }}
-    {%- elif content is iterable and content is not mapping %}
-        {%- for item in content %}
-            {%- if item is mapping %}
-                {%- if item.type == 'image' or 'image' in item or 'image_url' in item %}
-                    {%- if is_system_content %}
-                        {{- raise_exception('System message cannot contain images.') }}
-                    {%- endif %}
-                    {%- if do_vision_count %}
-                        {%- set image_count.value = image_count.value + 1 %}
-                    {%- endif %}
-                    {%- if add_vision_id %}
-                        {{- 'Picture ' ~ image_count.value ~ ': ' }}
-                    {%- endif %}
-                    {{- '<|vision_start|><|image_pad|><|vision_end|>' }}
-                {%- elif item.type == 'video' or 'video' in item %}
-                    {%- if is_system_content %}
-                        {{- raise_exception('System message cannot contain videos.') }}
-                    {%- endif %}
-                    {%- if do_vision_count %}
-                        {%- set video_count.value = video_count.value + 1 %}
-                    {%- endif %}
-                    {%- if add_vision_id %}
-                        {{- 'Video ' ~ video_count.value ~ ': ' }}
-                    {%- endif %}
-                    {{- '<|vision_start|><|video_pad|><|vision_end|>' }}
-                {%- elif 'text' in item %}
-                    {{- item.text }}
-                {%- else %}
-                    {{- raise_exception('Unexpected item type in content.') }}
-                {%- endif %}
-            {%- else %}
-                {{- item | string }}
-            {%- endif %}
-        {%- endfor %}
-    {%- elif content is none or content is undefined %}
-        {{- '' }}
-    {%- else %}
-        {{- raise_exception('Unexpected content type.') }}
-    {%- endif %}
-{%- endmacro %}
-{%- if not messages %}
-    {{- raise_exception('No messages provided.') }}
-{%- endif %}
-{%- set _first_role = messages[0].role %}
-{%- if _first_role == 'system' or _first_role == 'developer' %}
-    {%- set _sys_msg = messages[0] %}
-    {%- set _msgs = messages[1:] %}
-{%- else %}
-    {%- set _sys_msg = none %}
-    {%- set _msgs = messages %}
-{%- endif %}
-{%- set _sc = '' %}
-{%- if _sys_msg is not none %}
-    {%- set _sc = render_content(_sys_msg.content, false, true) | trim %}
-    {%- if '<|think_off|>' in _sc %}
-        {%- set _sc = _sc.split('<|think_off|>') | join('') | trim %}
-    {%- elif '<|think_on|>' in _sc %}
-        {%- set _sc = _sc.split('<|think_on|>') | join('') | trim %}
-    {%- endif %}
-{%- endif %}
-{%- if _has_tools %}
-    {{- '<|im_start|>system\n' }}
-    {%- if reasoning_instructions %}
-        {{- reasoning_instructions + '\n\n' }}
-    {%- endif %}
-    {{- '# Tools\n\nYou have access to the following functions:\n\n<tools>' }}
-    {%- for tool in tools %}
-        {{- '\n' }}
-        {{- tool | tojson }}
-    {%- endfor %}
-    {{- '\n</tools>' }}
-    {%- if _tool_format == 'json' %}
-        {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<think>\nBrief explanation of tool call\n</think>\n<tool_call>\n{"name": "example_function_name", "arguments": {"example_parameter_1": "value_1", "example_parameter_2": "This is the value for the second parameter"}}\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user.\n- ALL explanation and reasoning MUST be placed strictly inside the <think></think> block.\n- Function calls MUST follow the specified format: a single JSON object with "name" and "arguments" keys inside <tool_call></tool_call> XML tags.\n- If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after thinking, with NO conversational text before it.\n- The <tool_call> tag MUST be at the very beginning of a new line, with NO spaces or indentation before it.\n- To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks.\n- If you have all necessary data, provide your final answer directly to the user without any tool call.\n</IMPORTANT>' }}
-    {%- else %}
-        {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<think>\nBrief explanation of tool call\n</think>\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user.\n- ALL explanation and reasoning MUST be placed strictly inside the <think></think> block.\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags.\n- If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after thinking, with NO conversational text before it.\n- The <tool_call> and <function> tags MUST be at the very beginning of a new line, with NO spaces or indentation before them.\n- To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks.\n- If you have all necessary data, provide your final answer directly to the user without any tool call.\n</IMPORTANT>' }}
-    {%- endif %}
-    {%- if _sc %}
-        {{- '\n\n' + _sc }}
-    {%- endif %}
-    {{- '<|im_end|>\n' }}
-{%- else %}
-    {%- if _sc %}
-        {{- '<|im_start|>system\n' + (reasoning_instructions + '\n\n' if reasoning_instructions else '') + _sc + '<|im_end|>\n' }}
-    {%- elif reasoning_instructions %}
-        {{- '<|im_start|>system\n' + reasoning_instructions + '<|im_end|>\n' }}
-    {%- endif %}
-{%- endif %}
-{%- set _last_idx = _msgs | length - 1 %}
-{%- set ns = namespace(multi_step_tool=true, last_query_index=_last_idx) %}
-{%- for message in _msgs[::-1] %}
-    {%- set index = (_msgs | length - 1) - loop.index0 %}
-    {%- if ns.multi_step_tool and message.role == 'user' %}
-        {%- set _rc = render_content(message.content, false) | trim %}
-        {%- if not (_rc.startswith('<tool_response>') and _rc.endswith('</tool_response>')) %}
-            {%- set ns.multi_step_tool = false %}
-            {%- set ns.last_query_index = index %}
-        {%- endif %}
-    {%- endif %}
-{%- endfor %}
-{%- if ns.multi_step_tool %}
-    {%- if _last_idx > 50 %}
-        {%- set ns.last_query_index = _last_idx %}
-    {%- else %}
-        {%- set ns.last_query_index = 0 %}
-    {%- endif %}
-{%- endif %}
-{%- set ns2 = namespace(prev_role='', consecutive_failures=0) %}
-{%- for message in _msgs %}
-    {%- set is_system = (message.role == "system" or message.role == "developer") %}
-    {%- set content = render_content(message.content, true, is_system) | trim %}
-    {%- if is_system or message.role == 'user' %}
-        {%- if '<|think_off|>' in content %}
-            {%- set content = content.split('<|think_off|>') | join('') | trim %}
-        {%- elif '<|think_on|>' in content %}
-            {%- set content = content.split('<|think_on|>') | join('') | trim %}
-        {%- endif %}
-    {%- endif %}
-    {%- if is_system %}
-        {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}
-    {%- elif message.role == 'user' %}
-        {%- set ns2.consecutive_failures = 0 %}
-        {{- '<|im_start|>user\n' + content + '<|im_end|>\n' }}
-    {%- elif message.role == 'assistant' %}
-        {%- set reasoning_content = '' %}
-        {%- if message.reasoning_content is defined and message.reasoning_content is not none %}
-            {%- if message.reasoning_content is string %}
-                {%- set reasoning_content = message.reasoning_content %}
-            {%- else %}
-                {%- set reasoning_content = message.reasoning_content | string %}
-            {%- endif %}
-        {%- elif message.thinking is defined and message.thinking is not none %}
-            {%- if message.thinking is string %}
-                {%- set reasoning_content = message.thinking %}
-            {%- else %}
-                {%- set reasoning_content = message.thinking | string %}
-            {%- endif %}
-        {%- else %}
-            {%- set _think_end = '' %}
-            {%- if content.startswith('</think>') %}
-                {%- set _think_end = '</think>' %}
-            {%- elif content.startswith('</thinking>') %}
-                {%- set _think_end = '</thinking>' %}
-            {%- elif '\n</think>' in content %}
-                {%- set _think_end = '\n</think>' %}
-            {%- elif '\n</thinking>' in content %}
-                {%- set _think_end = '\n</thinking>' %}
-            {%- elif '\n</ think>' in content %}
-                {%- set _think_end = '\n</ think>' %}
-            {%- elif '\n</think >' in content %}
-                {%- set _think_end = '\n</think >' %}
-            {%- endif %}
-            {%- if _think_end %}
-                {%- if 'thinking' in _think_end %}
-                    {%- set _think_start = '<thinking>' %}
-                {%- else %}
-                    {%- set _think_start = '<think>' %}
-                {%- endif %}
-                {%- set reasoning_content = content.split(_think_end)[0].rstrip('\n') %}
-                {%- if _think_start in reasoning_content %}
-                    {%- set reasoning_content = reasoning_content.split(_think_start)[-1].lstrip('\n') %}
-                {%- endif %}
-                {%- set content = content.split(_think_end)[-1].lstrip('\n') %}
-            {%- endif %}
-        {%- endif %}
-        {%- set reasoning_content = reasoning_content | trim %}
-        {%- if (_preserve_thinking or loop.index0 > ns.last_query_index) and reasoning_content %}
-            {{- '<|im_start|>assistant\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}
-        {%- else %}
-            {{- '<|im_start|>assistant\n' + content }}
-        {%- endif %}
-        {%- if message.tool_calls is defined and message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}
-            {%- for tool_call in message.tool_calls %}
-                {%- if tool_call.function is defined and tool_call.function is not none %}
-                    {%- set tc = tool_call.function %}
-                {%- else %}
-                    {%- set tc = tool_call %}
-                {%- endif %}
-                {%- set tc_name = tc.name if (tc.name is defined and tc.name is not none) else '' %}
-                {%- if _tool_format == 'json' %}
-                    {%- if not loop.first or content | trim %}
-                        {{- '\n\n' }}
-                    {%- endif %}
-                    {%- set _args = '{}' %}
-                    {%- if tc.arguments is defined and tc.arguments is not none %}
-                        {%- if tc.arguments is mapping %}
-                            {%- set _args = tc.arguments | tojson %}
-                        {%- elif tc.arguments is string and tc.arguments %}
-                            {%- set _args = tc.arguments %}
-                        {%- endif %}
-                    {%- endif %}
-                    {{- '<tool_call>\n{"name": ' }}{{- tc_name | tojson }}{{- ', "arguments": ' }}{{- _args }}{{- '}\n</tool_call>' }}
-                {%- else %}
-                    {%- if loop.first %}
-                        {%- if content | trim %}
-                            {{- '\n\n<tool_call>\n<function=' + tc_name + '>\n' }}
-                        {%- else %}
-                            {{- '<tool_call>\n<function=' + tc_name + '>\n' }}
-                        {%- endif %}
-                    {%- else %}
-                        {{- '\n\n<tool_call>\n<function=' + tc_name + '>\n' }}
-                    {%- endif %}
-                    {%- if tc.arguments is defined and tc.arguments is not none %}
-                        {%- if tc.arguments is mapping %}
-                            {%- for args_name, args_value in tc.arguments.items() %}
-                                {{- '<parameter=' + args_name + '>\n' }}
-                                {%- if args_value is mapping or (args_value is sequence and args_value is not string) %}
-                                    {%- set _av = args_value | tojson %}
-                                {%- else %}
-                                    {%- set _av = args_value | string %}
-                                {%- endif %}
-                                {%- if max_tool_arg_chars > 0 and _av | length > max_tool_arg_chars %}
-                                    {{- _av[:max_tool_arg_chars] + '\n[TRUNCATED — original length ' ~ (_av | length | string) ~ ' chars]' }}
-                                {%- else %}
-                                    {{- _av }}
-                                {%- endif %}
-                                {{- '\n</parameter>\n' }}
-                            {%- endfor %}
-                        {%- elif tc.arguments is string and tc.arguments %}
-                            {{- tc.arguments }}
-                        {%- endif %}
-                    {%- endif %}
-                    {{- '</function>\n</tool_call>' }}
-                {%- endif %}
-            {%- endfor %}
-        {%- endif %}
-        {{- '<|im_end|>\n' }}
-    {%- elif message.role == 'tool' %}
-        {%- set _content_lower = content | lower %}
-        {%- set _content_head = _content_lower[:80] %}
-        {%- if content | length < 500 and '$ ' not in content and 'took ' not in _content_lower and ('"error":' in _content_head or 'error:' in _content_head or 'err!' in _content_head or 'fatal:' in _content_head or 'exception:' in _content_head or 'traceback' in _content_head or 'command not found' in _content_head or 'invalid syntax' in _content_head or 'failed to' in _content_head) %}
-            {%- set ns2.consecutive_failures = ns2.consecutive_failures + 1 %}
-        {%- else %}
-            {%- set ns2.consecutive_failures = 0 %}
-        {%- endif %}
-        {%- if ns2.prev_role != 'tool' %}
-            {{- '<|im_start|>user' }}
-        {%- endif %}
-        {%- if max_tool_response_chars > 0 and content | length > max_tool_response_chars %}
-            {%- set content = content[:max_tool_response_chars] + '\n[TRUNCATED — original length ' ~ (content | length | string) ~ ' chars]' %}
-        {%- endif %}
-        {{- '\n<tool_response>\n' + content }}
-        {%- if ns2.consecutive_failures >= 2 %}
-            {{- '\n\n⚠️ SYSTEM WARNING: ' ~ ns2.consecutive_failures ~ ' consecutive tool errors detected. Your previous approach is incorrect. You MUST use a fundamentally different approach or corrected arguments.' }}
-        {%- elif ns2.consecutive_failures == 1 %}
-            {{- '\n\n⚠️ SYSTEM WARNING: The previous tool call returned an error. Diagnose the failure and retry with completely corrected arguments.' }}
-        {%- endif %}
-        {{- '\n</tool_response>' }}
-        {%- if loop.last %}
-            {{- '<|im_end|>\n' }}
-        {%- else %}
-            {%- set _next_role = _msgs[loop.index0 + 1].role %}
-            {%- if _next_role != 'tool' %}
-                {{- '<|im_end|>\n' }}
-            {%- endif %}
-        {%- endif %}
-    {%- else %}
-        {{- '<|im_start|>user\n[' + message.role + ']: ' + content + '<|im_end|>\n' }}
-    {%- endif %}
-    {%- set ns2.prev_role = message.role %}
-{%- endfor %}
-{%- if add_generation_prompt %}
-    {{- '<|im_start|>assistant\n' }}
-    {%- if not ns_state.thinking %}
-        {{- '<think>\n\n</think>\n\n' }}
-    {%- else %}
-        {{- '<think>\n' }}
-    {%- endif %}
-{%- endif %}

archive/v22_chat_template_oneline.txt

@@ -1 +0,0 @@
-{%- set template_version = "qwen3.8-froggeric-v22" %}{%- set _tool_format = tool_call_format if tool_call_format is defined else 'xml' %}{%- set image_count = namespace(value=0) %}{%- set video_count = namespace(value=0) %}{%- set add_vision_id = add_vision_id if add_vision_id is defined else false %}{%- set enable_thinking = enable_thinking if enable_thinking is defined else true %}{%- set auto_disable_thinking_with_tools = auto_disable_thinking_with_tools if auto_disable_thinking_with_tools is defined else false %}{%- if preserve_reasoning is defined and preserve_reasoning is not none %}{%- set _preserve_thinking = preserve_reasoning %}{%- elif preserve_thinking is defined and preserve_thinking is not none %}{%- set _preserve_thinking = preserve_thinking %}{%- else %}{%- set _preserve_thinking = true %}{%- endif %}{%- set max_tool_arg_chars = max_tool_arg_chars if max_tool_arg_chars is defined else 0 %}{%- set max_tool_response_chars = max_tool_response_chars if max_tool_response_chars is defined else 0 %}{%- set _has_tools = (tools is defined and tools and tools is iterable and tools is not mapping) %}{%- set ns_state = namespace(thinking=enable_thinking) %}{%- if auto_disable_thinking_with_tools and _has_tools %}{%- set ns_state.thinking = false %}{%- endif %}{%- for msg in messages %}{%- if msg.role == 'system' or msg.role == 'developer' or msg.role == 'user' %}{%- if msg.content is string %}{%- if '<|think_off|>' in msg.content %}{%- set ns_state.thinking = false %}{%- elif '<|think_on|>' in msg.content %}{%- set ns_state.thinking = true %}{%- endif %}{%- elif msg.content is iterable and msg.content is not mapping %}{%- for item in msg.content %}{%- if item is mapping and 'text' in item and item.text is string %}{%- if '<|think_off|>' in item.text %}{%- set ns_state.thinking = false %}{%- elif '<|think_on|>' in item.text %}{%- set ns_state.thinking = true %}{%- endif %}{%- endif %}{%- endfor %}{%- endif %}{%- endif %}{%- endfor %}{%- set _effort_raw = reasoning_effort if reasoning_effort is defined else 'xhigh' %}{%- if _effort_raw == 'high' or _effort_raw == 'xhigh' %}{%- set _reasoning_effort = 'xhigh' %}{%- elif _effort_raw == 'low' %}{%- set _reasoning_effort = 'low' %}{%- elif _effort_raw == 'medium' %}{%- set _reasoning_effort = 'medium' %}{%- else %}{%- set _reasoning_effort = 'xhigh' %}{%- endif %}{%- set reasoning_instructions = '' %}{%- if ns_state.thinking %}{%- if _reasoning_effort == 'xhigh' %}{%- set reasoning_instructions = 'Reasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.' %}{%- elif _reasoning_effort == 'low' %}{%- set reasoning_instructions = 'Reasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration.' %}{%- endif %}{%- endif %}{%- macro render_content(content, do_vision_count, is_system_content=false) %}{%- if content is string %}{{- content }}{%- elif content is iterable and content is not mapping %}{%- for item in content %}{%- if item is mapping %}{%- if item.type == 'image' or 'image' in item or 'image_url' in item %}{%- if is_system_content %}{{- raise_exception('System message cannot contain images.') }}{%- endif %}{%- if do_vision_count %}{%- set image_count.value = image_count.value + 1 %}{%- endif %}{%- if add_vision_id %}{{- 'Picture ' ~ image_count.value ~ ': ' }}{%- endif %}{{- '<|vision_start|><|image_pad|><|vision_end|>' }}{%- elif item.type == 'video' or 'video' in item %}{%- if is_system_content %}{{- raise_exception('System message cannot contain videos.') }}{%- endif %}{%- if do_vision_count %}{%- set video_count.value = video_count.value + 1 %}{%- endif %}{%- if add_vision_id %}{{- 'Video ' ~ video_count.value ~ ': ' }}{%- endif %}{{- '<|vision_start|><|video_pad|><|vision_end|>' }}{%- elif 'text' in item %}{{- item.text }}{%- else %}{{- raise_exception('Unexpected item type in content.') }}{%- endif %}{%- else %}{{- item | string }}{%- endif %}{%- endfor %}{%- elif content is none or content is undefined %}{{- '' }}{%- else %}{{- raise_exception('Unexpected content type.') }}{%- endif %}{%- endmacro %}{%- if not messages %}{{- raise_exception('No messages provided.') }}{%- endif %}{%- set _first_role = messages[0].role %}{%- if _first_role == 'system' or _first_role == 'developer' %}{%- set _sys_msg = messages[0] %}{%- set _msgs = messages[1:] %}{%- else %}{%- set _sys_msg = none %}{%- set _msgs = messages %}{%- endif %}{%- set _sc = '' %}{%- if _sys_msg is not none %}{%- set _sc = render_content(_sys_msg.content, false, true) | trim %}{%- if '<|think_off|>' in _sc %}{%- set _sc = _sc.split('<|think_off|>') | join('') | trim %}{%- elif '<|think_on|>' in _sc %}{%- set _sc = _sc.split('<|think_on|>') | join('') | trim %}{%- endif %}{%- endif %}{%- if _has_tools %}{{- '<|im_start|>system\n' }}{%- if reasoning_instructions %}{{- reasoning_instructions + '\n\n' }}{%- endif %}{{- '# Tools\n\nYou have access to the following functions:\n\n<tools>' }}{%- for tool in tools %}{{- '\n' }}{{- tool | tojson }}{%- endfor %}{{- '\n</tools>' }}{%- if _tool_format == 'json' %}{{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<think>\nBrief explanation of tool call\n</think>\n<tool_call>\n{"name": "example_function_name", "arguments": {"example_parameter_1": "value_1", "example_parameter_2": "This is the value for the second parameter"}}\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user.\n- ALL explanation and reasoning MUST be placed strictly inside the <think></think> block.\n- Function calls MUST follow the specified format: a single JSON object with "name" and "arguments" keys inside <tool_call></tool_call> XML tags.\n- If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after thinking, with NO conversational text before it.\n- The <tool_call> tag MUST be at the very beginning of a new line, with NO spaces or indentation before it.\n- To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks.\n- If you have all necessary data, provide your final answer directly to the user without any tool call.\n</IMPORTANT>' }}{%- else %}{{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<think>\nBrief explanation of tool call\n</think>\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user.\n- ALL explanation and reasoning MUST be placed strictly inside the <think></think> block.\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags.\n- If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after thinking, with NO conversational text before it.\n- The <tool_call> and <function> tags MUST be at the very beginning of a new line, with NO spaces or indentation before them.\n- To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks.\n- If you have all necessary data, provide your final answer directly to the user without any tool call.\n</IMPORTANT>' }}{%- endif %}{%- if _sc %}{{- '\n\n' + _sc }}{%- endif %}{{- '<|im_end|>\n' }}{%- else %}{%- if _sc %}{{- '<|im_start|>system\n' + (reasoning_instructions + '\n\n' if reasoning_instructions else '') + _sc + '<|im_end|>\n' }}{%- elif reasoning_instructions %}{{- '<|im_start|>system\n' + reasoning_instructions + '<|im_end|>\n' }}{%- endif %}{%- endif %}{%- set _last_idx = _msgs | length - 1 %}{%- set ns = namespace(multi_step_tool=true, last_query_index=_last_idx) %}{%- for message in _msgs[::-1] %}{%- set index = (_msgs | length - 1) - loop.index0 %}{%- if ns.multi_step_tool and message.role == 'user' %}{%- set _rc = render_content(message.content, false) | trim %}{%- if not (_rc.startswith('<tool_response>') and _rc.endswith('</tool_response>')) %}{%- set ns.multi_step_tool = false %}{%- set ns.last_query_index = index %}{%- endif %}{%- endif %}{%- endfor %}{%- if ns.multi_step_tool %}{%- if _last_idx > 50 %}{%- set ns.last_query_index = _last_idx %}{%- else %}{%- set ns.last_query_index = 0 %}{%- endif %}{%- endif %}{%- set ns2 = namespace(prev_role='', consecutive_failures=0) %}{%- for message in _msgs %}{%- set is_system = (message.role == "system" or message.role == "developer") %}{%- set content = render_content(message.content, true, is_system) | trim %}{%- if is_system or message.role == 'user' %}{%- if '<|think_off|>' in content %}{%- set content = content.split('<|think_off|>') | join('') | trim %}{%- elif '<|think_on|>' in content %}{%- set content = content.split('<|think_on|>') | join('') | trim %}{%- endif %}{%- endif %}{%- if is_system %}{{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}{%- elif message.role == 'user' %}{%- set ns2.consecutive_failures = 0 %}{{- '<|im_start|>user\n' + content + '<|im_end|>\n' }}{%- elif message.role == 'assistant' %}{%- set reasoning_content = '' %}{%- if message.reasoning_content is defined and message.reasoning_content is not none %}{%- if message.reasoning_content is string %}{%- set reasoning_content = message.reasoning_content %}{%- else %}{%- set reasoning_content = message.reasoning_content | string %}{%- endif %}{%- elif message.thinking is defined and message.thinking is not none %}{%- if message.thinking is string %}{%- set reasoning_content = message.thinking %}{%- else %}{%- set reasoning_content = message.thinking | string %}{%- endif %}{%- else %}{%- set _think_end = '' %}{%- if content.startswith('</think>') %}{%- set _think_end = '</think>' %}{%- elif content.startswith('</thinking>') %}{%- set _think_end = '</thinking>' %}{%- elif '\n</think>' in content %}{%- set _think_end = '\n</think>' %}{%- elif '\n</thinking>' in content %}{%- set _think_end = '\n</thinking>' %}{%- elif '\n</ think>' in content %}{%- set _think_end = '\n</ think>' %}{%- elif '\n</think >' in content %}{%- set _think_end = '\n</think >' %}{%- endif %}{%- if _think_end %}{%- if 'thinking' in _think_end %}{%- set _think_start = '<thinking>' %}{%- else %}{%- set _think_start = '<think>' %}{%- endif %}{%- set reasoning_content = content.split(_think_end)[0].rstrip('\n') %}{%- if _think_start in reasoning_content %}{%- set reasoning_content = reasoning_content.split(_think_start)[-1].lstrip('\n') %}{%- endif %}{%- set content = content.split(_think_end)[-1].lstrip('\n') %}{%- endif %}{%- endif %}{%- set reasoning_content = reasoning_content | trim %}{%- if (_preserve_thinking or loop.index0 > ns.last_query_index) and reasoning_content %}{{- '<|im_start|>assistant\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}{%- else %}{{- '<|im_start|>assistant\n' + content }}{%- endif %}{%- if message.tool_calls is defined and message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}{%- for tool_call in message.tool_calls %}{%- if tool_call.function is defined and tool_call.function is not none %}{%- set tc = tool_call.function %}{%- else %}{%- set tc = tool_call %}{%- endif %}{%- set tc_name = tc.name if (tc.name is defined and tc.name is not none) else '' %}{%- if _tool_format == 'json' %}{%- if not loop.first or content | trim %}{{- '\n\n' }}{%- endif %}{%- set _args = '{}' %}{%- if tc.arguments is defined and tc.arguments is not none %}{%- if tc.arguments is mapping %}{%- set _args = tc.arguments | tojson %}{%- elif tc.arguments is string and tc.arguments %}{%- set _args = tc.arguments %}{%- endif %}{%- endif %}{{- '<tool_call>\n{"name": ' }}{{- tc_name | tojson }}{{- ', "arguments": ' }}{{- _args }}{{- '}\n</tool_call>' }}{%- else %}{%- if loop.first %}{%- if content | trim %}{{- '\n\n<tool_call>\n<function=' + tc_name + '>\n' }}{%- else %}{{- '<tool_call>\n<function=' + tc_name + '>\n' }}{%- endif %}{%- else %}{{- '\n\n<tool_call>\n<function=' + tc_name + '>\n' }}{%- endif %}{%- if tc.arguments is defined and tc.arguments is not none %}{%- if tc.arguments is mapping %}{%- for args_name, args_value in tc.arguments.items() %}{{- '<parameter=' + args_name + '>\n' }}{%- if args_value is mapping or (args_value is sequence and args_value is not string) %}{%- set _av = args_value | tojson %}{%- else %}{%- set _av = args_value | string %}{%- endif %}{%- if max_tool_arg_chars > 0 and _av | length > max_tool_arg_chars %}{{- _av[:max_tool_arg_chars] + '\n[TRUNCATED — original length ' ~ (_av | length | string) ~ ' chars]' }}{%- else %}{{- _av }}{%- endif %}{{- '\n</parameter>\n' }}{%- endfor %}{%- elif tc.arguments is string and tc.arguments %}{{- tc.arguments }}{%- endif %}{%- endif %}{{- '</function>\n</tool_call>' }}{%- endif %}{%- endfor %}{%- endif %}{{- '<|im_end|>\n' }}{%- elif message.role == 'tool' %}{%- set _content_lower = content | lower %}{%- set _content_head = _content_lower[:80] %}{%- if content | length < 500 and '$ ' not in content and 'took ' not in _content_lower and ('"error":' in _content_head or 'error:' in _content_head or 'err!' in _content_head or 'fatal:' in _content_head or 'exception:' in _content_head or 'traceback' in _content_head or 'command not found' in _content_head or 'invalid syntax' in _content_head or 'failed to' in _content_head) %}{%- set ns2.consecutive_failures = ns2.consecutive_failures + 1 %}{%- else %}{%- set ns2.consecutive_failures = 0 %}{%- endif %}{%- if ns2.prev_role != 'tool' %}{{- '<|im_start|>user' }}{%- endif %}{%- if max_tool_response_chars > 0 and content | length > max_tool_response_chars %}{%- set content = content[:max_tool_response_chars] + '\n[TRUNCATED — original length ' ~ (content | length | string) ~ ' chars]' %}{%- endif %}{{- '\n<tool_response>\n' + content }}{%- if ns2.consecutive_failures >= 2 %}{{- '\n\n⚠️ SYSTEM WARNING: ' ~ ns2.consecutive_failures ~ ' consecutive tool errors detected. Your previous approach is incorrect. You MUST use a fundamentally different approach or corrected arguments.' }}{%- elif ns2.consecutive_failures == 1 %}{{- '\n\n⚠️ SYSTEM WARNING: The previous tool call returned an error. Diagnose the failure and retry with completely corrected arguments.' }}{%- endif %}{{- '\n</tool_response>' }}{%- if loop.last %}{{- '<|im_end|>\n' }}{%- else %}{%- set _next_role = _msgs[loop.index0 + 1].role %}{%- if _next_role != 'tool' %}{{- '<|im_end|>\n' }}{%- endif %}{%- endif %}{%- else %}{{- '<|im_start|>user\n[' + message.role + ']: ' + content + '<|im_end|>\n' }}{%- endif %}{%- set ns2.prev_role = message.role %}{%- endfor %}{%- if add_generation_prompt %}{{- '<|im_start|>assistant\n' }}{%- if not ns_state.thinking %}{{- '<think>\n\n</think>\n\n' }}{%- else %}{{- '<think>\n' }}{%- endif %}{%- endif %}

chat_template.jinja

@@ -1,91 +1,17 @@
-{%- set template_version = "qwen3.8-froggeric-v22.4" %}
-{%- set _tool_format = tool_call_format if tool_call_format is defined else 'xml' %}
+{%- set template_version = "qwen3.6-froggeric-v20" %}
 {%- set image_count = namespace(value=0) %}
 {%- set video_count = namespace(value=0) %}
 {%- set add_vision_id = add_vision_id if add_vision_id is defined else false %}
 {%- set enable_thinking = enable_thinking if enable_thinking is defined else true %}
 {%- set auto_disable_thinking_with_tools = auto_disable_thinking_with_tools if auto_disable_thinking_with_tools is defined else false %}
-{%- if preserve_reasoning is defined and preserve_reasoning is not none %}
-    {%- set _preserve_thinking = preserve_reasoning %}
-{%- elif preserve_thinking is defined and preserve_thinking is not none %}
-    {%- set _preserve_thinking = preserve_thinking %}
-{%- else %}
-    {%- set _preserve_thinking = true %}
-{%- endif %}
+{%- set _preserve_thinking = preserve_thinking if preserve_thinking is defined else false %}
 {%- set max_tool_arg_chars = max_tool_arg_chars if max_tool_arg_chars is defined else 0 %}
 {%- set max_tool_response_chars = max_tool_response_chars if max_tool_response_chars is defined else 0 %}
-{%- set _default_reasoning_effort = 'medium' %}
 {%- set _has_tools = (tools is defined and tools and tools is iterable and tools is not mapping) %}
-{%- set _effort_raw = (reasoning_effort | string | lower) if reasoning_effort is defined and reasoning_effort is not none else _default_reasoning_effort %}
-{%- set _initial_thinking = enable_thinking %}
-{%- if _effort_raw in ('none', 'off') %}
-    {%- set _initial_thinking = false %}
-    {%- set _initial_effort = 'medium' %}
-{%- elif _effort_raw in ('minimal', 'low') %}
-    {%- set _initial_effort = 'low' %}
-{%- elif _effort_raw in ('high', 'xhigh', 'max', 'ultracode', 'extreme') %}
-    {%- set _initial_effort = 'xhigh' %}
-{%- else %}
-    {%- set _initial_effort = 'medium' %}
-{%- endif %}
-{%- set ns_state = namespace(thinking=_initial_thinking, effort=_initial_effort) %}
+{%- set ns_state = namespace(thinking=enable_thinking) %}
 {%- if auto_disable_thinking_with_tools and _has_tools %}
     {%- set ns_state.thinking = false %}
 {%- endif %}
-{%- for msg in messages %}
-    {%- if msg.role == 'system' or msg.role == 'developer' or msg.role == 'user' %}
-        {%- if msg.content is string %}
-            {%- if '<|think_off|>' in msg.content %}
-                {%- set ns_state.thinking = false %}
-            {%- elif '<|think_on|>' in msg.content %}
-                {%- set ns_state.thinking = true %}
-            {%- elif '<|think_xhigh|>' in msg.content or '<|think_high|>' in msg.content or '<|think_ultracode|>' in msg.content or '<|think_extreme|>' in msg.content or '<|think_max|>' in msg.content %}
-                {%- set ns_state.thinking = true %}
-                {%- set ns_state.effort = 'xhigh' %}
-            {%- elif '<|think_low|>' in msg.content or '<|think_minimal|>' in msg.content %}
-                {%- set ns_state.thinking = true %}
-                {%- set ns_state.effort = 'low' %}
-            {%- elif '<|think_medium|>' in msg.content %}
-                {%- set ns_state.thinking = true %}
-                {%- set ns_state.effort = 'medium' %}
-            {%- endif %}
-        {%- elif msg.content is iterable and msg.content is not mapping %}
-            {%- for item in msg.content %}
-                {%- if item is string %}
-                    {%- set _item_text = item %}
-                {%- elif item is mapping and 'text' in item and item.text is string %}
-                    {%- set _item_text = item.text %}
-                {%- else %}
-                    {%- set _item_text = '' %}
-                {%- endif %}
-                {%- if _item_text %}
-                    {%- if '<|think_off|>' in _item_text %}
-                        {%- set ns_state.thinking = false %}
-                    {%- elif '<|think_on|>' in _item_text %}
-                        {%- set ns_state.thinking = true %}
-                    {%- elif '<|think_xhigh|>' in _item_text or '<|think_high|>' in _item_text or '<|think_ultracode|>' in _item_text or '<|think_extreme|>' in _item_text or '<|think_max|>' in _item_text %}
-                        {%- set ns_state.thinking = true %}
-                        {%- set ns_state.effort = 'xhigh' %}
-                    {%- elif '<|think_low|>' in _item_text or '<|think_minimal|>' in _item_text %}
-                        {%- set ns_state.thinking = true %}
-                        {%- set ns_state.effort = 'low' %}
-                    {%- elif '<|think_medium|>' in _item_text %}
-                        {%- set ns_state.thinking = true %}
-                        {%- set ns_state.effort = 'medium' %}
-                    {%- endif %}
-                {%- endif %}
-            {%- endfor %}
-        {%- endif %}
-    {%- endif %}
-{%- endfor %}
-{%- set reasoning_instructions = '' %}
-{%- if ns_state.thinking %}
-    {%- if ns_state.effort == 'xhigh' %}
-        {%- set reasoning_instructions = 'Reasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.' %}
-    {%- elif ns_state.effort == 'low' %}
-        {%- set reasoning_instructions = 'Reasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration.' %}
-    {%- endif %}
-{%- endif %}
 {%- macro render_content(content, do_vision_count, is_system_content=false) %}
     {%- if content is string %}
         {{- content }}
@@ -132,63 +58,71 @@
 {%- if not messages %}
     {{- raise_exception('No messages provided.') }}
 {%- endif %}
-{%- set head = namespace(count=0, seen_non_system=false) %}
-{%- for message in messages %}
-    {%- set _is_sys = (message.role == 'system' or message.role == 'developer') %}
-    {%- if _is_sys and not head.seen_non_system %}
-        {%- set head.count = head.count + 1 %}
-    {%- else %}
-        {%- set head.seen_non_system = true %}
-    {%- endif %}
-{%- endfor %}
-{%- set sys_state = namespace(content='') %}
-{%- for message in messages[:head.count] %}
-    {%- set _part = render_content(message.content, false, true) | trim %}
-    {%- if '<|think_off|>' in _part %}{%- set _part = _part.split('<|think_off|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_on|>' in _part %}{%- set _part = _part.split('<|think_on|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_xhigh|>' in _part %}{%- set _part = _part.split('<|think_xhigh|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_high|>' in _part %}{%- set _part = _part.split('<|think_high|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_ultracode|>' in _part %}{%- set _part = _part.split('<|think_ultracode|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_extreme|>' in _part %}{%- set _part = _part.split('<|think_extreme|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_max|>' in _part %}{%- set _part = _part.split('<|think_max|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_medium|>' in _part %}{%- set _part = _part.split('<|think_medium|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_low|>' in _part %}{%- set _part = _part.split('<|think_low|>') | join('') | trim %}{%- endif %}
-    {%- if '<|think_minimal|>' in _part %}{%- set _part = _part.split('<|think_minimal|>') | join('') | trim %}{%- endif %}
-    {%- if _part %}
-        {%- if sys_state.content %}
-            {%- set sys_state.content = sys_state.content ~ '\n\n' ~ _part %}
-        {%- else %}
-            {%- set sys_state.content = _part %}
-        {%- endif %}
+{%- set _first_role = messages[0].role %}
+{%- if _first_role == 'system' or _first_role == 'developer' %}
+    {%- set _sys_msg = messages[0] %}
+    {%- set _msgs = messages[1:] %}
+{%- else %}
+    {%- set _sys_msg = none %}
+    {%- set _msgs = messages %}
+{%- endif %}
+{%- set _sc = '' %}
+{%- if _sys_msg is not none %}
+    {%- set _sc = render_content(_sys_msg.content, false, true) | trim %}
+    {%- if '<|think_off|>' in _sc %}
+        {%- set ns_state.thinking = false %}
+        {%- set _sc = _sc.split('<|think_off|>') | join('') | trim %}
+    {%- elif '<|think_on|>' in _sc %}
+        {%- set ns_state.thinking = true %}
+        {%- set _sc = _sc.split('<|think_on|>') | join('') | trim %}
     {%- endif %}
-{%- endfor %}
-{%- set _sc = sys_state.content %}
-{%- set _msgs = messages[head.count:] %}
+{%- endif %}
 {%- if _has_tools %}
     {{- '<|im_start|>system\n' }}
-    {%- if reasoning_instructions %}
-        {{- reasoning_instructions + '\n\n' }}
-    {%- endif %}
     {{- '# Tools\n\nYou have access to the following functions:\n\n<tools>' }}
     {%- for tool in tools %}
         {{- '\n' }}
         {{- tool | tojson }}
     {%- endfor %}
     {{- '\n</tools>' }}
-    {%- if _tool_format == 'json' %}
-        {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<think>\nBrief explanation of tool call\n</think>\n<tool_call>\n{"name": "example_function_name", "arguments": {"example_parameter_1": "value_1", "example_parameter_2": "This is the value for the second parameter"}}\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user.\n- ALL explanation and reasoning MUST be placed strictly inside the <think></think> block.\n- Function calls MUST follow the specified format: a single JSON object with "name" and "arguments" keys inside <tool_call></tool_call> XML tags.\n- If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after thinking, with NO conversational text before it.\n- The <tool_call> tag MUST be at the very beginning of a new line, with NO spaces or indentation before it.\n- To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks.\n- If you have all necessary data, provide your final answer directly to the user without any tool call.\n</IMPORTANT>' }}
-    {%- else %}
-        {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<think>\nBrief explanation of tool call\n</think>\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user.\n- ALL explanation and reasoning MUST be placed strictly inside the <think></think> block.\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags.\n- If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after thinking, with NO conversational text before it.\n- The <tool_call> and <function> tags MUST be at the very beginning of a new line, with NO spaces or indentation before them.\n- To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks.\n- If you have all necessary data, provide your final answer directly to the user without any tool call.\n</IMPORTANT>' }}
-    {%- endif %}
+    {%- set tool_instructions %}
+If you choose to call a function ONLY reply in the following format with NO suffix:
+
+<think>
+Brief explanation of tool call
+</think>
+<tool_call>
+<function=example_function_name>
+<parameter=example_parameter_1>
+value_1
+</parameter>
+<parameter=example_parameter_2>
+This is the value for the second parameter
+that can span
+multiple lines
+</parameter>
+</function>
+</tool_call>
+
+<IMPORTANT>
+Reminder:
+- You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user.
+- ALL explanation and reasoning MUST be placed strictly inside the <think></think> block.
+- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags.
+- If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after closing </think>. Do NOT output any conversational text before the tool call.
+- The <tool_call> and <function> tags MUST be at the very beginning of a new line, with NO spaces or indentation before them.
+- To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks.
+- If you have gathered all necessary data and do not need to call a tool, answer the question like normal and provide your final response to the user IMMEDIATELY after closing </think>.
+</IMPORTANT>
+    {%- endset %}
+    {{- '\n\n' ~ tool_instructions | trim }}
     {%- if _sc %}
         {{- '\n\n' + _sc }}
     {%- endif %}
     {{- '<|im_end|>\n' }}
 {%- else %}
     {%- if _sc %}
-        {{- '<|im_start|>system\n' + (reasoning_instructions + '\n\n' if reasoning_instructions else '') + _sc + '<|im_end|>\n' }}
-    {%- elif reasoning_instructions %}
-        {{- '<|im_start|>system\n' + reasoning_instructions + '<|im_end|>\n' }}
+        {{- '<|im_start|>system\n' + _sc + '<|im_end|>\n' }}
     {%- endif %}
 {%- endif %}
 {%- set _last_idx = _msgs | length - 1 %}
@@ -215,16 +149,13 @@
     {%- set is_system = (message.role == "system" or message.role == "developer") %}
     {%- set content = render_content(message.content, true, is_system) | trim %}
     {%- if is_system or message.role == 'user' %}
-        {%- if '<|think_off|>' in content %}{%- set content = content.split('<|think_off|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_on|>' in content %}{%- set content = content.split('<|think_on|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_xhigh|>' in content %}{%- set content = content.split('<|think_xhigh|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_high|>' in content %}{%- set content = content.split('<|think_high|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_ultracode|>' in content %}{%- set content = content.split('<|think_ultracode|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_extreme|>' in content %}{%- set content = content.split('<|think_extreme|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_max|>' in content %}{%- set content = content.split('<|think_max|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_medium|>' in content %}{%- set content = content.split('<|think_medium|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_low|>' in content %}{%- set content = content.split('<|think_low|>') | join('') | trim %}{%- endif %}
-        {%- if '<|think_minimal|>' in content %}{%- set content = content.split('<|think_minimal|>') | join('') | trim %}{%- endif %}
+        {%- if '<|think_off|>' in content %}
+            {%- set ns_state.thinking = false %}
+            {%- set content = content.split('<|think_off|>') | join('') | trim %}
+        {%- elif '<|think_on|>' in content %}
+            {%- set ns_state.thinking = true %}
+            {%- set content = content.split('<|think_on|>') | join('') | trim %}
+        {%- endif %}
     {%- endif %}
     {%- if is_system %}
         {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}
@@ -233,62 +164,25 @@
         {{- '<|im_start|>user\n' + content + '<|im_end|>\n' }}
     {%- elif message.role == 'assistant' %}
         {%- set reasoning_content = '' %}
-        {%- set _explicit_reasoning = '' %}
         {%- if message.reasoning_content is defined and message.reasoning_content is not none %}
             {%- if message.reasoning_content is string %}
-                {%- set _explicit_reasoning = message.reasoning_content %}
+                {%- set reasoning_content = message.reasoning_content %}
             {%- else %}
-                {%- set _explicit_reasoning = message.reasoning_content | string %}
-            {%- endif %}
-        {%- elif message.thinking is defined and message.thinking is not none %}
-            {%- if message.thinking is string %}
-                {%- set _explicit_reasoning = message.thinking %}
-            {%- else %}
-                {%- set _explicit_reasoning = message.thinking | string %}
-            {%- endif %}
-        {%- elif message.reasoning is defined and message.reasoning is not none %}
-            {%- if message.reasoning is string %}
-                {%- set _explicit_reasoning = message.reasoning %}
-            {%- else %}
-                {%- set _explicit_reasoning = message.reasoning | string %}
-            {%- endif %}
-        {%- endif %}
-        {%- if _explicit_reasoning %}
-            {%- set _lead_end = '' %}
-            {%- if content.startswith('<think>') and '</think>' in content %}
-                {%- set _lead_end = '</think>' %}
-            {%- elif content.startswith('<thinking>') and '</thinking>' in content %}
-                {%- set _lead_end = '</thinking>' %}
-            {%- elif content.startswith('</think>') %}
-                {%- set _lead_end = '</think>' %}
-            {%- elif content.startswith('</thinking>') %}
-                {%- set _lead_end = '</thinking>' %}
+                {%- set reasoning_content = message.reasoning_content | string %}
             {%- endif %}
-            {%- if _lead_end %}
-                {%- set content = content.split(_lead_end)[-1].lstrip('\n') %}
-            {%- endif %}
-            {%- set reasoning_content = _explicit_reasoning %}
         {%- else %}
             {%- set _think_end = '' %}
-            {%- if content.startswith('</think>') %}
-                {%- set _think_end = '</think>' %}
-            {%- elif content.startswith('</thinking>') %}
-                {%- set _think_end = '</thinking>' %}
-            {%- elif '\n</think>' in content %}
-                {%- set _think_end = '\n</think>' %}
-            {%- elif '\n</thinking>' in content %}
-                {%- set _think_end = '\n</thinking>' %}
-            {%- elif '\n</ think>' in content %}
-                {%- set _think_end = '\n</ think>' %}
-            {%- elif '\n</think >' in content %}
-                {%- set _think_end = '\n</think >' %}
-            {%- elif content.startswith('<think>') and '</think>' in content %}
+            {%- if '</think>' in content %}
                 {%- set _think_end = '</think>' %}
-            {%- elif content.startswith('<thinking>') and '</thinking>' in content %}
+            {%- elif '</thinking>' in content %}
                 {%- set _think_end = '</thinking>' %}
+            {%- elif '</ think>' in content %}
+                {%- set _think_end = '</ think>' %}
+            {%- elif '</think >' in content %}
+                {%- set _think_end = '</think >' %}
             {%- endif %}
             {%- if _think_end %}
-                {%- if 'thinking' in _think_end %}
+                {%- if _think_end == '</thinking>' %}
                     {%- set _think_start = '<thinking>' %}
                 {%- else %}
                     {%- set _think_start = '<think>' %}
@@ -301,7 +195,7 @@
             {%- endif %}
         {%- endif %}
         {%- set reasoning_content = reasoning_content | trim %}
-        {%- if (_preserve_thinking or loop.index0 > ns.last_query_index) %}
+        {%- if (_preserve_thinking or loop.index0 > ns.last_query_index) and reasoning_content %}
             {{- '<|im_start|>assistant\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}
         {%- else %}
             {{- '<|im_start|>assistant\n' + content }}
@@ -313,69 +207,38 @@
                 {%- else %}
                     {%- set tc = tool_call %}
                 {%- endif %}
-                {%- set tc_name = tc.name if (tc.name is defined and tc.name is not none) else '' %}
-                {%- if _tool_format == 'json' %}
-                    {%- if loop.first %}
-                        {%- if content | trim %}
-                            {{- '\n\n' }}
-                        {%- endif %}
+                {%- if loop.first %}
+                    {%- if content | trim %}
+                        {{- '\n\n<tool_call>\n<function=' + tc.name + '>\n' }}
                     {%- else %}
-                        {{- '\n' }}
+                        {{- '<tool_call>\n<function=' + tc.name + '>\n' }}
                     {%- endif %}
-                    {%- set _args = '{}' %}
-                    {%- if tc.arguments is defined and tc.arguments is not none %}
-                        {%- if tc.arguments is mapping %}
-                            {%- set _args = tc.arguments | tojson %}
-                        {%- elif tc.arguments is string %}
-                            {%- if tc.arguments %}
-                                {%- set _args = tc.arguments %}
-                            {%- endif %}
-                        {%- else %}
-                            {%- set _args = tc.arguments | tojson %}
-                        {%- endif %}
-                    {%- endif %}
-                    {{- '<tool_call>\n{"name": ' }}{{- tc_name | tojson }}{{- ', "arguments": ' }}{{- _args }}{{- '}\n</tool_call>' }}
                 {%- else %}
-                    {%- if loop.first %}
-                        {%- if content | trim %}
-                            {{- '\n\n<tool_call>\n<function=' + tc_name + '>\n' }}
-                        {%- else %}
-                            {{- '<tool_call>\n<function=' + tc_name + '>\n' }}
-                        {%- endif %}
-                    {%- else %}
-                        {{- '\n<tool_call>\n<function=' + tc_name + '>\n' }}
-                    {%- endif %}
-                    {%- if tc.arguments is defined and tc.arguments is not none %}
-                        {%- if tc.arguments is mapping %}
-                            {%- for args_name, args_value in tc.arguments.items() %}
-                                {{- '<parameter=' + args_name + '>\n' }}
-                                {%- if args_value is string %}
-                                    {%- set _av = args_value %}
-                                {%- else %}
-                                    {%- set _av = args_value | tojson %}
-                                {%- endif %}
-                                {%- if max_tool_arg_chars > 0 and _av | length > max_tool_arg_chars %}
-                                    {{- _av[:max_tool_arg_chars] + '\n[TRUNCATED - original length ' ~ (_av | length | string) ~ ' chars]' }}
-                                {%- else %}
-                                    {{- _av }}
-                                {%- endif %}
-                                {{- '\n</parameter>\n' }}
-                            {%- endfor %}
-                        {%- else %}
-                            {%- if tc.arguments is string %}
-                                {%- set _raw_args = tc.arguments %}
+                    {{- '\n\n<tool_call>\n<function=' + tc.name + '>\n' }}
+                {%- endif %}
+                {%- if tc.arguments is defined and tc.arguments is not none %}
+                    {%- if tc.arguments is mapping %}
+                        {%- for args_name, args_value in tc.arguments.items() %}
+                            {{- '<parameter=' + args_name + '>\n' }}
+                            {%- if args_value is mapping or (args_value is sequence and args_value is not string) %}
+                                {%- set _av = args_value | tojson %}
                             {%- else %}
-                                {%- set _raw_args = tc.arguments | tojson %}
+                                {%- set _av = args_value | string %}
                             {%- endif %}
-                            {%- if _raw_args %}
-                                {%- if max_tool_arg_chars > 0 and _raw_args | length > max_tool_arg_chars %}
-                                    {{- _raw_args[:max_tool_arg_chars] + '\n[TRUNCATED - original length ' ~ (_raw_args | length | string) ~ ' chars]' }}
-                                {%- else %}
-                                    {{- _raw_args }}
-                                {%- endif %}
+                            {%- if max_tool_arg_chars > 0 and _av | length > max_tool_arg_chars %}
+                                {{- _av[:max_tool_arg_chars] + '\n[TRUNCATED — original length ' ~ (_av | length | string) ~ ' chars]' }}
+                            {%- else %}
+                                {{- _av }}
                             {%- endif %}
-                        {%- endif %}
+                            {{- '\n</parameter>\n' }}
+                        {%- endfor %}
+                    {%- elif tc.arguments is string and tc.arguments %}
+                        {{- tc.arguments }}
                     {%- endif %}
+                {%- endif %}
+                {%- if loop.last %}
+                    {{- '</function>\n</tool_call>\n' }}
+                {%- else %}
                     {{- '</function>\n</tool_call>' }}
                 {%- endif %}
             {%- endfor %}
@@ -383,14 +246,7 @@
         {{- '<|im_end|>\n' }}
     {%- elif message.role == 'tool' %}
         {%- set _content_lower = content | lower %}
-        {%- set _content_head = _content_lower[:120] %}
-        {%- set _is_code_or_grep = ('throw new ' in _content_lower or 'throw error' in _content_lower or 'console.error' in _content_lower or 'logger.error' in _content_lower or 'logging.error' in _content_lower or 'import ' in _content_head or 'def ' in _content_head or 'function ' in _content_head) %}
-        {%- set _exit_code_zero = ('exit code: 0' in _content_head or 'process exited with code 0' in _content_head) %}
-        {%- set _error_field_ok = ('"error": null' in _content_head or '"error":null' in _content_head or '"error": false' in _content_head or '"error":false' in _content_head or '"error": ""' in _content_head or '"error":""' in _content_head) %}
-        {%- set _strong_error = (('"error":' in _content_head and not _error_field_ok) or '"status": "error"' in _content_head or '"status":"error"' in _content_head or 'traceback (most recent call last):' in _content_head or 'command not found' in _content_head or 'invalid syntax' in _content_head or 'fatal:' in _content_head or (('exit code: ' in _content_head or 'process exited with code' in _content_head) and not _exit_code_zero) or _content_head.startswith('exception:') or _content_head.startswith('failed to ')) %}
-        {%- set _weak_error = ('error:' in _content_head or 'err!' in _content_head) %}
-        {%- set _weak_suppressed = ('$ ' in _content_head or 'took ' in _content_head or content | length >= 600) %}
-        {%- if not _is_code_or_grep and (_strong_error or (_weak_error and not _weak_suppressed)) %}
+        {%- if content | length < 500 and '$ ' not in content and 'took ' not in _content_lower and ('"error":' in _content_lower or 'error:' in _content_lower or 'exception:' in _content_lower or 'traceback' in _content_lower or 'command not found' in _content_lower or 'invalid syntax' in _content_lower or 'failed to' in _content_lower) %}
             {%- set ns2.consecutive_failures = ns2.consecutive_failures + 1 %}
         {%- else %}
             {%- set ns2.consecutive_failures = 0 %}
@@ -398,8 +254,8 @@
         {%- if ns2.prev_role != 'tool' %}
             {{- '<|im_start|>user' }}
         {%- endif %}
-        {%- if _tool_format != 'json' and max_tool_response_chars > 0 and content | length > max_tool_response_chars %}
-            {%- set content = content[:max_tool_response_chars] + '\n[TRUNCATED - original length ' ~ (content | length | string) ~ ' chars]' %}
+        {%- if max_tool_response_chars > 0 and content | length > max_tool_response_chars %}
+            {%- set content = content[:max_tool_response_chars] + '\n[TRUNCATED — original length ' ~ (content | length | string) ~ ' chars]' %}
         {%- endif %}
         {{- '\n<tool_response>\n' + content }}
         {%- if ns2.consecutive_failures >= 2 %}
@@ -424,7 +280,9 @@
 {%- if add_generation_prompt %}
     {{- '<|im_start|>assistant\n' }}
     {%- if not ns_state.thinking %}
-        {{- '<think>\n\n</think>\n\n' }}
+        {{- '<think>\n</think>\n' }}
+    {%- elif ns2.consecutive_failures >= 2 %}
+        {{- '<think>\n</think>\n' }}
     {%- else %}
         {{- '<think>\n' }}
     {%- endif %}

chat_template_oneline.txt

@@ -1 +1 @@
-{%- set template_version = "qwen3.8-froggeric-v22.4" %}{%- set _tool_format = tool_call_format if tool_call_format is defined else 'xml' %}{%- set image_count = namespace(value=0) %}{%- set video_count = namespace(value=0) %}{%- set add_vision_id = add_vision_id if add_vision_id is defined else false %}{%- set enable_thinking = enable_thinking if enable_thinking is defined else true %}{%- set auto_disable_thinking_with_tools = auto_disable_thinking_with_tools if auto_disable_thinking_with_tools is defined else false %}{%- if preserve_reasoning is defined and preserve_reasoning is not none %}{%- set _preserve_thinking = preserve_reasoning %}{%- elif preserve_thinking is defined and preserve_thinking is not none %}{%- set _preserve_thinking = preserve_thinking %}{%- else %}{%- set _preserve_thinking = true %}{%- endif %}{%- set max_tool_arg_chars = max_tool_arg_chars if max_tool_arg_chars is defined else 0 %}{%- set max_tool_response_chars = max_tool_response_chars if max_tool_response_chars is defined else 0 %}{%- set _default_reasoning_effort = 'medium' %}{%- set _has_tools = (tools is defined and tools and tools is iterable and tools is not mapping) %}{%- set _effort_raw = (reasoning_effort | string | lower) if reasoning_effort is defined and reasoning_effort is not none else _default_reasoning_effort %}{%- set _initial_thinking = enable_thinking %}{%- if _effort_raw in ('none', 'off') %}{%- set _initial_thinking = false %}{%- set _initial_effort = 'medium' %}{%- elif _effort_raw in ('minimal', 'low') %}{%- set _initial_effort = 'low' %}{%- elif _effort_raw in ('high', 'xhigh', 'max', 'ultracode', 'extreme') %}{%- set _initial_effort = 'xhigh' %}{%- else %}{%- set _initial_effort = 'medium' %}{%- endif %}{%- set ns_state = namespace(thinking=_initial_thinking, effort=_initial_effort) %}{%- if auto_disable_thinking_with_tools and _has_tools %}{%- set ns_state.thinking = false %}{%- endif %}{%- for msg in messages %}{%- if msg.role == 'system' or msg.role == 'developer' or msg.role == 'user' %}{%- if msg.content is string %}{%- if '<|think_off|>' in msg.content %}{%- set ns_state.thinking = false %}{%- elif '<|think_on|>' in msg.content %}{%- set ns_state.thinking = true %}{%- elif '<|think_xhigh|>' in msg.content or '<|think_high|>' in msg.content or '<|think_ultracode|>' in msg.content or '<|think_extreme|>' in msg.content or '<|think_max|>' in msg.content %}{%- set ns_state.thinking = true %}{%- set ns_state.effort = 'xhigh' %}{%- elif '<|think_low|>' in msg.content or '<|think_minimal|>' in msg.content %}{%- set ns_state.thinking = true %}{%- set ns_state.effort = 'low' %}{%- elif '<|think_medium|>' in msg.content %}{%- set ns_state.thinking = true %}{%- set ns_state.effort = 'medium' %}{%- endif %}{%- elif msg.content is iterable and msg.content is not mapping %}{%- for item in msg.content %}{%- if item is string %}{%- set _item_text = item %}{%- elif item is mapping and 'text' in item and item.text is string %}{%- set _item_text = item.text %}{%- else %}{%- set _item_text = '' %}{%- endif %}{%- if _item_text %}{%- if '<|think_off|>' in _item_text %}{%- set ns_state.thinking = false %}{%- elif '<|think_on|>' in _item_text %}{%- set ns_state.thinking = true %}{%- elif '<|think_xhigh|>' in _item_text or '<|think_high|>' in _item_text or '<|think_ultracode|>' in _item_text or '<|think_extreme|>' in _item_text or '<|think_max|>' in _item_text %}{%- set ns_state.thinking = true %}{%- set ns_state.effort = 'xhigh' %}{%- elif '<|think_low|>' in _item_text or '<|think_minimal|>' in _item_text %}{%- set ns_state.thinking = true %}{%- set ns_state.effort = 'low' %}{%- elif '<|think_medium|>' in _item_text %}{%- set ns_state.thinking = true %}{%- set ns_state.effort = 'medium' %}{%- endif %}{%- endif %}{%- endfor %}{%- endif %}{%- endif %}{%- endfor %}{%- set reasoning_instructions = '' %}{%- if ns_state.thinking %}{%- if ns_state.effort == 'xhigh' %}{%- set reasoning_instructions = 'Reasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.' %}{%- elif ns_state.effort == 'low' %}{%- set reasoning_instructions = 'Reasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration.' %}{%- endif %}{%- endif %}{%- macro render_content(content, do_vision_count, is_system_content=false) %}{%- if content is string %}{{- content }}{%- elif content is iterable and content is not mapping %}{%- for item in content %}{%- if item is mapping %}{%- if item.type == 'image' or 'image' in item or 'image_url' in item %}{%- if is_system_content %}{{- raise_exception('System message cannot contain images.') }}{%- endif %}{%- if do_vision_count %}{%- set image_count.value = image_count.value + 1 %}{%- endif %}{%- if add_vision_id %}{{- 'Picture ' ~ image_count.value ~ ': ' }}{%- endif %}{{- '<|vision_start|><|image_pad|><|vision_end|>' }}{%- elif item.type == 'video' or 'video' in item %}{%- if is_system_content %}{{- raise_exception('System message cannot contain videos.') }}{%- endif %}{%- if do_vision_count %}{%- set video_count.value = video_count.value + 1 %}{%- endif %}{%- if add_vision_id %}{{- 'Video ' ~ video_count.value ~ ': ' }}{%- endif %}{{- '<|vision_start|><|video_pad|><|vision_end|>' }}{%- elif 'text' in item %}{{- item.text }}{%- else %}{{- raise_exception('Unexpected item type in content.') }}{%- endif %}{%- else %}{{- item | string }}{%- endif %}{%- endfor %}{%- elif content is none or content is undefined %}{{- '' }}{%- else %}{{- raise_exception('Unexpected content type.') }}{%- endif %}{%- endmacro %}{%- if not messages %}{{- raise_exception('No messages provided.') }}{%- endif %}{%- set head = namespace(count=0, seen_non_system=false) %}{%- for message in messages %}{%- set _is_sys = (message.role == 'system' or message.role == 'developer') %}{%- if _is_sys and not head.seen_non_system %}{%- set head.count = head.count + 1 %}{%- else %}{%- set head.seen_non_system = true %}{%- endif %}{%- endfor %}{%- set sys_state = namespace(content='') %}{%- for message in messages[:head.count] %}{%- set _part = render_content(message.content, false, true) | trim %}{%- if '<|think_off|>' in _part %}{%- set _part = _part.split('<|think_off|>') | join('') | trim %}{%- endif %}{%- if '<|think_on|>' in _part %}{%- set _part = _part.split('<|think_on|>') | join('') | trim %}{%- endif %}{%- if '<|think_xhigh|>' in _part %}{%- set _part = _part.split('<|think_xhigh|>') | join('') | trim %}{%- endif %}{%- if '<|think_high|>' in _part %}{%- set _part = _part.split('<|think_high|>') | join('') | trim %}{%- endif %}{%- if '<|think_ultracode|>' in _part %}{%- set _part = _part.split('<|think_ultracode|>') | join('') | trim %}{%- endif %}{%- if '<|think_extreme|>' in _part %}{%- set _part = _part.split('<|think_extreme|>') | join('') | trim %}{%- endif %}{%- if '<|think_max|>' in _part %}{%- set _part = _part.split('<|think_max|>') | join('') | trim %}{%- endif %}{%- if '<|think_medium|>' in _part %}{%- set _part = _part.split('<|think_medium|>') | join('') | trim %}{%- endif %}{%- if '<|think_low|>' in _part %}{%- set _part = _part.split('<|think_low|>') | join('') | trim %}{%- endif %}{%- if '<|think_minimal|>' in _part %}{%- set _part = _part.split('<|think_minimal|>') | join('') | trim %}{%- endif %}{%- if _part %}{%- if sys_state.content %}{%- set sys_state.content = sys_state.content ~ '\n\n' ~ _part %}{%- else %}{%- set sys_state.content = _part %}{%- endif %}{%- endif %}{%- endfor %}{%- set _sc = sys_state.content %}{%- set _msgs = messages[head.count:] %}{%- if _has_tools %}{{- '<|im_start|>system\n' }}{%- if reasoning_instructions %}{{- reasoning_instructions + '\n\n' }}{%- endif %}{{- '# Tools\n\nYou have access to the following functions:\n\n<tools>' }}{%- for tool in tools %}{{- '\n' }}{{- tool | tojson }}{%- endfor %}{{- '\n</tools>' }}{%- if _tool_format == 'json' %}{{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<think>\nBrief explanation of tool call\n</think>\n<tool_call>\n{"name": "example_function_name", "arguments": {"example_parameter_1": "value_1", "example_parameter_2": "This is the value for the second parameter"}}\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user.\n- ALL explanation and reasoning MUST be placed strictly inside the <think></think> block.\n- Function calls MUST follow the specified format: a single JSON object with "name" and "arguments" keys inside <tool_call></tool_call> XML tags.\n- If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after thinking, with NO conversational text before it.\n- The <tool_call> tag MUST be at the very beginning of a new line, with NO spaces or indentation before it.\n- To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks.\n- If you have all necessary data, provide your final answer directly to the user without any tool call.\n</IMPORTANT>' }}{%- else %}{{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<think>\nBrief explanation of tool call\n</think>\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user.\n- ALL explanation and reasoning MUST be placed strictly inside the <think></think> block.\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags.\n- If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after thinking, with NO conversational text before it.\n- The <tool_call> and <function> tags MUST be at the very beginning of a new line, with NO spaces or indentation before them.\n- To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks.\n- If you have all necessary data, provide your final answer directly to the user without any tool call.\n</IMPORTANT>' }}{%- endif %}{%- if _sc %}{{- '\n\n' + _sc }}{%- endif %}{{- '<|im_end|>\n' }}{%- else %}{%- if _sc %}{{- '<|im_start|>system\n' + (reasoning_instructions + '\n\n' if reasoning_instructions else '') + _sc + '<|im_end|>\n' }}{%- elif reasoning_instructions %}{{- '<|im_start|>system\n' + reasoning_instructions + '<|im_end|>\n' }}{%- endif %}{%- endif %}{%- set _last_idx = _msgs | length - 1 %}{%- set ns = namespace(multi_step_tool=true, last_query_index=_last_idx) %}{%- for message in _msgs[::-1] %}{%- set index = (_msgs | length - 1) - loop.index0 %}{%- if ns.multi_step_tool and message.role == 'user' %}{%- set _rc = render_content(message.content, false) | trim %}{%- if not (_rc.startswith('<tool_response>') and _rc.endswith('</tool_response>')) %}{%- set ns.multi_step_tool = false %}{%- set ns.last_query_index = index %}{%- endif %}{%- endif %}{%- endfor %}{%- if ns.multi_step_tool %}{%- if _last_idx > 50 %}{%- set ns.last_query_index = _last_idx %}{%- else %}{%- set ns.last_query_index = 0 %}{%- endif %}{%- endif %}{%- set ns2 = namespace(prev_role='', consecutive_failures=0) %}{%- for message in _msgs %}{%- set is_system = (message.role == "system" or message.role == "developer") %}{%- set content = render_content(message.content, true, is_system) | trim %}{%- if is_system or message.role == 'user' %}{%- if '<|think_off|>' in content %}{%- set content = content.split('<|think_off|>') | join('') | trim %}{%- endif %}{%- if '<|think_on|>' in content %}{%- set content = content.split('<|think_on|>') | join('') | trim %}{%- endif %}{%- if '<|think_xhigh|>' in content %}{%- set content = content.split('<|think_xhigh|>') | join('') | trim %}{%- endif %}{%- if '<|think_high|>' in content %}{%- set content = content.split('<|think_high|>') | join('') | trim %}{%- endif %}{%- if '<|think_ultracode|>' in content %}{%- set content = content.split('<|think_ultracode|>') | join('') | trim %}{%- endif %}{%- if '<|think_extreme|>' in content %}{%- set content = content.split('<|think_extreme|>') | join('') | trim %}{%- endif %}{%- if '<|think_max|>' in content %}{%- set content = content.split('<|think_max|>') | join('') | trim %}{%- endif %}{%- if '<|think_medium|>' in content %}{%- set content = content.split('<|think_medium|>') | join('') | trim %}{%- endif %}{%- if '<|think_low|>' in content %}{%- set content = content.split('<|think_low|>') | join('') | trim %}{%- endif %}{%- if '<|think_minimal|>' in content %}{%- set content = content.split('<|think_minimal|>') | join('') | trim %}{%- endif %}{%- endif %}{%- if is_system %}{{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}{%- elif message.role == 'user' %}{%- set ns2.consecutive_failures = 0 %}{{- '<|im_start|>user\n' + content + '<|im_end|>\n' }}{%- elif message.role == 'assistant' %}{%- set reasoning_content = '' %}{%- set _explicit_reasoning = '' %}{%- if message.reasoning_content is defined and message.reasoning_content is not none %}{%- if message.reasoning_content is string %}{%- set _explicit_reasoning = message.reasoning_content %}{%- else %}{%- set _explicit_reasoning = message.reasoning_content | string %}{%- endif %}{%- elif message.thinking is defined and message.thinking is not none %}{%- if message.thinking is string %}{%- set _explicit_reasoning = message.thinking %}{%- else %}{%- set _explicit_reasoning = message.thinking | string %}{%- endif %}{%- elif message.reasoning is defined and message.reasoning is not none %}{%- if message.reasoning is string %}{%- set _explicit_reasoning = message.reasoning %}{%- else %}{%- set _explicit_reasoning = message.reasoning | string %}{%- endif %}{%- endif %}{%- if _explicit_reasoning %}{%- set _lead_end = '' %}{%- if content.startswith('<think>') and '</think>' in content %}{%- set _lead_end = '</think>' %}{%- elif content.startswith('<thinking>') and '</thinking>' in content %}{%- set _lead_end = '</thinking>' %}{%- elif content.startswith('</think>') %}{%- set _lead_end = '</think>' %}{%- elif content.startswith('</thinking>') %}{%- set _lead_end = '</thinking>' %}{%- endif %}{%- if _lead_end %}{%- set content = content.split(_lead_end)[-1].lstrip('\n') %}{%- endif %}{%- set reasoning_content = _explicit_reasoning %}{%- else %}{%- set _think_end = '' %}{%- if content.startswith('</think>') %}{%- set _think_end = '</think>' %}{%- elif content.startswith('</thinking>') %}{%- set _think_end = '</thinking>' %}{%- elif '\n</think>' in content %}{%- set _think_end = '\n</think>' %}{%- elif '\n</thinking>' in content %}{%- set _think_end = '\n</thinking>' %}{%- elif '\n</ think>' in content %}{%- set _think_end = '\n</ think>' %}{%- elif '\n</think >' in content %}{%- set _think_end = '\n</think >' %}{%- elif content.startswith('<think>') and '</think>' in content %}{%- set _think_end = '</think>' %}{%- elif content.startswith('<thinking>') and '</thinking>' in content %}{%- set _think_end = '</thinking>' %}{%- endif %}{%- if _think_end %}{%- if 'thinking' in _think_end %}{%- set _think_start = '<thinking>' %}{%- else %}{%- set _think_start = '<think>' %}{%- endif %}{%- set reasoning_content = content.split(_think_end)[0].rstrip('\n') %}{%- if _think_start in reasoning_content %}{%- set reasoning_content = reasoning_content.split(_think_start)[-1].lstrip('\n') %}{%- endif %}{%- set content = content.split(_think_end)[-1].lstrip('\n') %}{%- endif %}{%- endif %}{%- set reasoning_content = reasoning_content | trim %}{%- if (_preserve_thinking or loop.index0 > ns.last_query_index) %}{{- '<|im_start|>assistant\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}{%- else %}{{- '<|im_start|>assistant\n' + content }}{%- endif %}{%- if message.tool_calls is defined and message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}{%- for tool_call in message.tool_calls %}{%- if tool_call.function is defined and tool_call.function is not none %}{%- set tc = tool_call.function %}{%- else %}{%- set tc = tool_call %}{%- endif %}{%- set tc_name = tc.name if (tc.name is defined and tc.name is not none) else '' %}{%- if _tool_format == 'json' %}{%- if loop.first %}{%- if content | trim %}{{- '\n\n' }}{%- endif %}{%- else %}{{- '\n' }}{%- endif %}{%- set _args = '{}' %}{%- if tc.arguments is defined and tc.arguments is not none %}{%- if tc.arguments is mapping %}{%- set _args = tc.arguments | tojson %}{%- elif tc.arguments is string %}{%- if tc.arguments %}{%- set _args = tc.arguments %}{%- endif %}{%- else %}{%- set _args = tc.arguments | tojson %}{%- endif %}{%- endif %}{{- '<tool_call>\n{"name": ' }}{{- tc_name | tojson }}{{- ', "arguments": ' }}{{- _args }}{{- '}\n</tool_call>' }}{%- else %}{%- if loop.first %}{%- if content | trim %}{{- '\n\n<tool_call>\n<function=' + tc_name + '>\n' }}{%- else %}{{- '<tool_call>\n<function=' + tc_name + '>\n' }}{%- endif %}{%- else %}{{- '\n<tool_call>\n<function=' + tc_name + '>\n' }}{%- endif %}{%- if tc.arguments is defined and tc.arguments is not none %}{%- if tc.arguments is mapping %}{%- for args_name, args_value in tc.arguments.items() %}{{- '<parameter=' + args_name + '>\n' }}{%- if args_value is string %}{%- set _av = args_value %}{%- else %}{%- set _av = args_value | tojson %}{%- endif %}{%- if max_tool_arg_chars > 0 and _av | length > max_tool_arg_chars %}{{- _av[:max_tool_arg_chars] + '\n[TRUNCATED - original length ' ~ (_av | length | string) ~ ' chars]' }}{%- else %}{{- _av }}{%- endif %}{{- '\n</parameter>\n' }}{%- endfor %}{%- else %}{%- if tc.arguments is string %}{%- set _raw_args = tc.arguments %}{%- else %}{%- set _raw_args = tc.arguments | tojson %}{%- endif %}{%- if _raw_args %}{%- if max_tool_arg_chars > 0 and _raw_args | length > max_tool_arg_chars %}{{- _raw_args[:max_tool_arg_chars] + '\n[TRUNCATED - original length ' ~ (_raw_args | length | string) ~ ' chars]' }}{%- else %}{{- _raw_args }}{%- endif %}{%- endif %}{%- endif %}{%- endif %}{{- '</function>\n</tool_call>' }}{%- endif %}{%- endfor %}{%- endif %}{{- '<|im_end|>\n' }}{%- elif message.role == 'tool' %}{%- set _content_lower = content | lower %}{%- set _content_head = _content_lower[:120] %}{%- set _is_code_or_grep = ('throw new ' in _content_lower or 'throw error' in _content_lower or 'console.error' in _content_lower or 'logger.error' in _content_lower or 'logging.error' in _content_lower or 'import ' in _content_head or 'def ' in _content_head or 'function ' in _content_head) %}{%- set _exit_code_zero = ('exit code: 0' in _content_head or 'process exited with code 0' in _content_head) %}{%- set _error_field_ok = ('"error": null' in _content_head or '"error":null' in _content_head or '"error": false' in _content_head or '"error":false' in _content_head or '"error": ""' in _content_head or '"error":""' in _content_head) %}{%- set _strong_error = (('"error":' in _content_head and not _error_field_ok) or '"status": "error"' in _content_head or '"status":"error"' in _content_head or 'traceback (most recent call last):' in _content_head or 'command not found' in _content_head or 'invalid syntax' in _content_head or 'fatal:' in _content_head or (('exit code: ' in _content_head or 'process exited with code' in _content_head) and not _exit_code_zero) or _content_head.startswith('exception:') or _content_head.startswith('failed to ')) %}{%- set _weak_error = ('error:' in _content_head or 'err!' in _content_head) %}{%- set _weak_suppressed = ('$ ' in _content_head or 'took ' in _content_head or content | length >= 600) %}{%- if not _is_code_or_grep and (_strong_error or (_weak_error and not _weak_suppressed)) %}{%- set ns2.consecutive_failures = ns2.consecutive_failures + 1 %}{%- else %}{%- set ns2.consecutive_failures = 0 %}{%- endif %}{%- if ns2.prev_role != 'tool' %}{{- '<|im_start|>user' }}{%- endif %}{%- if _tool_format != 'json' and max_tool_response_chars > 0 and content | length > max_tool_response_chars %}{%- set content = content[:max_tool_response_chars] + '\n[TRUNCATED - original length ' ~ (content | length | string) ~ ' chars]' %}{%- endif %}{{- '\n<tool_response>\n' + content }}{%- if ns2.consecutive_failures >= 2 %}{{- '\n\n⚠️ SYSTEM WARNING: ' ~ ns2.consecutive_failures ~ ' consecutive tool errors detected. Your previous approach is incorrect. You MUST use a fundamentally different approach or corrected arguments.' }}{%- elif ns2.consecutive_failures == 1 %}{{- '\n\n⚠️ SYSTEM WARNING: The previous tool call returned an error. Diagnose the failure and retry with completely corrected arguments.' }}{%- endif %}{{- '\n</tool_response>' }}{%- if loop.last %}{{- '<|im_end|>\n' }}{%- else %}{%- set _next_role = _msgs[loop.index0 + 1].role %}{%- if _next_role != 'tool' %}{{- '<|im_end|>\n' }}{%- endif %}{%- endif %}{%- else %}{{- '<|im_start|>user\n[' + message.role + ']: ' + content + '<|im_end|>\n' }}{%- endif %}{%- set ns2.prev_role = message.role %}{%- endfor %}{%- if add_generation_prompt %}{{- '<|im_start|>assistant\n' }}{%- if not ns_state.thinking %}{{- '<think>\n\n</think>\n\n' }}{%- else %}{{- '<think>\n' }}{%- endif %}{%- endif %}
+{%- set template_version = "qwen3.6-froggeric-v20" %}{%- set image_count = namespace(value=0) %}{%- set video_count = namespace(value=0) %}{%- set add_vision_id = add_vision_id if add_vision_id is defined else false %}{%- set enable_thinking = enable_thinking if enable_thinking is defined else true %}{%- set auto_disable_thinking_with_tools = auto_disable_thinking_with_tools if auto_disable_thinking_with_tools is defined else false %}{%- set _preserve_thinking = preserve_thinking if preserve_thinking is defined else false %}{%- set max_tool_arg_chars = max_tool_arg_chars if max_tool_arg_chars is defined else 0 %}{%- set max_tool_response_chars = max_tool_response_chars if max_tool_response_chars is defined else 0 %}{%- set _has_tools = (tools is defined and tools and tools is iterable and tools is not mapping) %}{%- set ns_state = namespace(thinking=enable_thinking) %}{%- if auto_disable_thinking_with_tools and _has_tools %}{%- set ns_state.thinking = false %}{%- endif %}{%- macro render_content(content, do_vision_count, is_system_content=false) %}{%- if content is string %}{{- content }}{%- elif content is iterable and content is not mapping %}{%- for item in content %}{%- if item is mapping %}{%- if item.type == 'image' or 'image' in item or 'image_url' in item %}{%- if is_system_content %}{{- raise_exception('System message cannot contain images.') }}{%- endif %}{%- if do_vision_count %}{%- set image_count.value = image_count.value + 1 %}{%- endif %}{%- if add_vision_id %}{{- 'Picture ' ~ image_count.value ~ ': ' }}{%- endif %}{{- '<|vision_start|><|image_pad|><|vision_end|>' }}{%- elif item.type == 'video' or 'video' in item %}{%- if is_system_content %}{{- raise_exception('System message cannot contain videos.') }}{%- endif %}{%- if do_vision_count %}{%- set video_count.value = video_count.value + 1 %}{%- endif %}{%- if add_vision_id %}{{- 'Video ' ~ video_count.value ~ ': ' }}{%- endif %}{{- '<|vision_start|><|video_pad|><|vision_end|>' }}{%- elif 'text' in item %}{{- item.text }}{%- else %}{{- raise_exception('Unexpected item type in content.') }}{%- endif %}{%- else %}{{- item | string }}{%- endif %}{%- endfor %}{%- elif content is none or content is undefined %}{{- '' }}{%- else %}{{- raise_exception('Unexpected content type.') }}{%- endif %}{%- endmacro %}{%- if not messages %}{{- raise_exception('No messages provided.') }}{%- endif %}{%- set _first_role = messages[0].role %}{%- if _first_role == 'system' or _first_role == 'developer' %}{%- set _sys_msg = messages[0] %}{%- set _msgs = messages[1:] %}{%- else %}{%- set _sys_msg = none %}{%- set _msgs = messages %}{%- endif %}{%- set _sc = '' %}{%- if _sys_msg is not none %}{%- set _sc = render_content(_sys_msg.content, false, true) | trim %}{%- if '<|think_off|>' in _sc %}{%- set ns_state.thinking = false %}{%- set _sc = _sc.split('<|think_off|>') | join('') | trim %}{%- elif '<|think_on|>' in _sc %}{%- set ns_state.thinking = true %}{%- set _sc = _sc.split('<|think_on|>') | join('') | trim %}{%- endif %}{%- endif %}{%- if _has_tools %}{{- '<|im_start|>system\n' }}{{- '# Tools\n\nYou have access to the following functions:\n\n<tools>' }}{%- for tool in tools %}{{- '\n' }}{{- tool | tojson }}{%- endfor %}{{- '\n</tools>' }}{%- set tool_instructions %} If you choose to call a function ONLY reply in the following format with NO suffix: <think> Brief explanation of tool call </think> <tool_call> <function=example_function_name> <parameter=example_parameter_1> value_1 </parameter> <parameter=example_parameter_2> This is the value for the second parameter that can span multiple lines </parameter> </function> </tool_call> <IMPORTANT> Reminder: - You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user. - ALL explanation and reasoning MUST be placed strictly inside the <think></think> block. - Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags. - If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after closing </think>. Do NOT output any conversational text before the tool call. - The <tool_call> and <function> tags MUST be at the very beginning of a new line, with NO spaces or indentation before them. - To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks. - If you have gathered all necessary data and do not need to call a tool, answer the question like normal and provide your final response to the user IMMEDIATELY after closing </think>. </IMPORTANT> {%- endset %}{{- '\n\n' ~ tool_instructions | trim }}{%- if _sc %}{{- '\n\n' + _sc }}{%- endif %}{{- '<|im_end|>\n' }}{%- else %}{%- if _sc %}{{- '<|im_start|>system\n' + _sc + '<|im_end|>\n' }}{%- endif %}{%- endif %}{%- set _last_idx = _msgs | length - 1 %}{%- set ns = namespace(multi_step_tool=true, last_query_index=_last_idx) %}{%- for message in _msgs[::-1] %}{%- set index = (_msgs | length - 1) - loop.index0 %}{%- if ns.multi_step_tool and message.role == 'user' %}{%- set _rc = render_content(message.content, false) | trim %}{%- if not (_rc.startswith('<tool_response>') and _rc.endswith('</tool_response>')) %}{%- set ns.multi_step_tool = false %}{%- set ns.last_query_index = index %}{%- endif %}{%- endif %}{%- endfor %}{%- if ns.multi_step_tool %}{%- if _last_idx > 50 %}{%- set ns.last_query_index = _last_idx %}{%- else %}{%- set ns.last_query_index = 0 %}{%- endif %}{%- endif %}{%- set ns2 = namespace(prev_role='', consecutive_failures=0) %}{%- for message in _msgs %}{%- set is_system = (message.role == "system" or message.role == "developer") %}{%- set content = render_content(message.content, true, is_system) | trim %}{%- if is_system or message.role == 'user' %}{%- if '<|think_off|>' in content %}{%- set ns_state.thinking = false %}{%- set content = content.split('<|think_off|>') | join('') | trim %}{%- elif '<|think_on|>' in content %}{%- set ns_state.thinking = true %}{%- set content = content.split('<|think_on|>') | join('') | trim %}{%- endif %}{%- endif %}{%- if is_system %}{{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}{%- elif message.role == 'user' %}{%- set ns2.consecutive_failures = 0 %}{{- '<|im_start|>user\n' + content + '<|im_end|>\n' }}{%- elif message.role == 'assistant' %}{%- set reasoning_content = '' %}{%- if message.reasoning_content is defined and message.reasoning_content is not none %}{%- if message.reasoning_content is string %}{%- set reasoning_content = message.reasoning_content %}{%- else %}{%- set reasoning_content = message.reasoning_content | string %}{%- endif %}{%- else %}{%- set _think_end = '' %}{%- if '</think>' in content %}{%- set _think_end = '</think>' %}{%- elif '</thinking>' in content %}{%- set _think_end = '</thinking>' %}{%- elif '</ think>' in content %}{%- set _think_end = '</ think>' %}{%- elif '</think >' in content %}{%- set _think_end = '</think >' %}{%- endif %}{%- if _think_end %}{%- if _think_end == '</thinking>' %}{%- set _think_start = '<thinking>' %}{%- else %}{%- set _think_start = '<think>' %}{%- endif %}{%- set reasoning_content = content.split(_think_end)[0].rstrip('\n') %}{%- if _think_start in reasoning_content %}{%- set reasoning_content = reasoning_content.split(_think_start)[-1].lstrip('\n') %}{%- endif %}{%- set content = content.split(_think_end)[-1].lstrip('\n') %}{%- endif %}{%- endif %}{%- set reasoning_content = reasoning_content | trim %}{%- if (_preserve_thinking or loop.index0 > ns.last_query_index) and reasoning_content %}{{- '<|im_start|>assistant\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}{%- else %}{{- '<|im_start|>assistant\n' + content }}{%- endif %}{%- if message.tool_calls is defined and message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}{%- for tool_call in message.tool_calls %}{%- if tool_call.function is defined and tool_call.function is not none %}{%- set tc = tool_call.function %}{%- else %}{%- set tc = tool_call %}{%- endif %}{%- if loop.first %}{%- if content | trim %}{{- '\n\n<tool_call>\n<function=' + tc.name + '>\n' }}{%- else %}{{- '<tool_call>\n<function=' + tc.name + '>\n' }}{%- endif %}{%- else %}{{- '\n\n<tool_call>\n<function=' + tc.name + '>\n' }}{%- endif %}{%- if tc.arguments is defined and tc.arguments is not none %}{%- if tc.arguments is mapping %}{%- for args_name, args_value in tc.arguments.items() %}{{- '<parameter=' + args_name + '>\n' }}{%- if args_value is mapping or (args_value is sequence and args_value is not string) %}{%- set _av = args_value | tojson %}{%- else %}{%- set _av = args_value | string %}{%- endif %}{%- if max_tool_arg_chars > 0 and _av | length > max_tool_arg_chars %}{{- _av[:max_tool_arg_chars] + '\n[TRUNCATED — original length ' ~ (_av | length | string) ~ ' chars]' }}{%- else %}{{- _av }}{%- endif %}{{- '\n</parameter>\n' }}{%- endfor %}{%- elif tc.arguments is string and tc.arguments %}{{- tc.arguments }}{%- endif %}{%- endif %}{%- if loop.last %}{{- '</function>\n</tool_call>\n' }}{%- else %}{{- '</function>\n</tool_call>' }}{%- endif %}{%- endfor %}{%- endif %}{{- '<|im_end|>\n' }}{%- elif message.role == 'tool' %}{%- set _content_lower = content | lower %}{%- if content | length < 500 and '$ ' not in content and 'took ' not in _content_lower and ('"error":' in _content_lower or 'error:' in _content_lower or 'exception:' in _content_lower or 'traceback' in _content_lower or 'command not found' in _content_lower or 'invalid syntax' in _content_lower or 'failed to' in _content_lower) %}{%- set ns2.consecutive_failures = ns2.consecutive_failures + 1 %}{%- else %}{%- set ns2.consecutive_failures = 0 %}{%- endif %}{%- if ns2.prev_role != 'tool' %}{{- '<|im_start|>user' }}{%- endif %}{%- if max_tool_response_chars > 0 and content | length > max_tool_response_chars %}{%- set content = content[:max_tool_response_chars] + '\n[TRUNCATED — original length ' ~ (content | length | string) ~ ' chars]' %}{%- endif %}{{- '\n<tool_response>\n' + content }}{%- if ns2.consecutive_failures >= 2 %}{{- '\n\n⚠️ SYSTEM WARNING: ' ~ ns2.consecutive_failures ~ ' consecutive tool errors detected. Your previous approach is incorrect. You MUST use a fundamentally different approach or corrected arguments.' }}{%- elif ns2.consecutive_failures == 1 %}{{- '\n\n⚠️ SYSTEM WARNING: The previous tool call returned an error. Diagnose the failure and retry with completely corrected arguments.' }}{%- endif %}{{- '\n</tool_response>' }}{%- if loop.last %}{{- '<|im_end|>\n' }}{%- else %}{%- set _next_role = _msgs[loop.index0 + 1].role %}{%- if _next_role != 'tool' %}{{- '<|im_end|>\n' }}{%- endif %}{%- endif %}{%- else %}{{- '<|im_start|>user\n[' + message.role + ']: ' + content + '<|im_end|>\n' }}{%- endif %}{%- set ns2.prev_role = message.role %}{%- endfor %}{%- if add_generation_prompt %}{{- '<|im_start|>assistant\n' }}{%- if not ns_state.thinking %}{{- '<think>\n</think>\n' }}{%- elif ns2.consecutive_failures >= 2 %}{{- '<think>\n</think>\n' }}{%- else %}{{- '<think>\n' }}{%- endif %}{%- endif %}

scripts/check_applied.py

@@ -1,139 +0,0 @@
-#!/usr/bin/env python3
-"""Diagnostic utility to verify which chat template is active on a model directory or GGUF file.
-
-Usage:
-    python3 scripts/check_applied.py [path_to_model_dir_or_gguf]
-
-Examples:
-    python3 scripts/check_applied.py .
-    python3 scripts/check_applied.py /models/Qwen3.8-27B-Instruct
-    python3 scripts/check_applied.py /models/qwen3.8-27b.gguf
-"""
-
-import sys
-import os
-import re
-import json
-
-GREEN = "\033[92m"
-RED = "\033[91m"
-YELLOW = "\033[93m"
-CYAN = "\033[96m"
-BOLD = "\033[1m"
-RESET = "\033[0m"
-
-
-def extract_template_version(content: str) -> str:
-    if not content:
-        return "None"
-    m = re.search(r'template_version\s*=\s*["\']([^"\']+)["\']', content)
-    if m:
-        return m.group(1)
-    if "qwen" in content.lower() or "im_start" in content:
-        return "Stock / Unknown Qwen Template"
-    return "Unknown"
-
-
-def inspect_gguf(path: str):
-    try:
-        import gguf
-        reader = gguf.GGUFReader(path)
-        for field in reader.fields.values():
-            if field.name == "tokenizer.chat_template":
-                parts = field.parts
-                for idx in field.data:
-                    val = str(parts[idx])
-                    if "im_start" in val:
-                        return val
-        return None
-    except ImportError:
-        # Fallback: simple binary scan for template string
-        try:
-            with open(path, "rb") as f:
-                # Read first 10MB of GGUF header
-                buf = f.read(10 * 1024 * 1024).decode("utf-8", errors="ignore")
-                m = re.search(r'template_version\s*=\s*["\']([^"\']+)["\']', buf)
-                if m:
-                    return f'{{%- set template_version = "{m.group(1)}" %}}'
-        except Exception:
-            pass
-        return None
-    except Exception as e:
-        return None
-
-
-def main():
-    target = sys.argv[1] if len(sys.argv) > 1 else "."
-
-    print(f"\n{BOLD}{CYAN}=== Qwen Chat Template Diagnostic Utility ==={RESET}")
-    print(f"Target: {os.path.abspath(target)}\n")
-
-    sources = {}
-
-    if os.path.isfile(target):
-        if target.endswith(".gguf"):
-            gguf_template = inspect_gguf(target)
-            sources["gguf"] = gguf_template
-        elif target.endswith(".jinja"):
-            with open(target, "r", encoding="utf-8") as f:
-                sources["chat_template.jinja"] = f.read()
-        elif target.endswith(".json"):
-            with open(target, "r", encoding="utf-8") as f:
-                data = json.load(f)
-                sources["tokenizer_config.json"] = data.get("chat_template", "")
-    elif os.path.isdir(target):
-        jinja_path = os.path.join(target, "chat_template.jinja")
-        json_path = os.path.join(target, "tokenizer_config.json")
-
-        if os.path.exists(jinja_path):
-            with open(jinja_path, "r", encoding="utf-8") as f:
-                sources["chat_template.jinja"] = f.read()
-
-        if os.path.exists(json_path):
-            try:
-                with open(json_path, "r", encoding="utf-8") as f:
-                    data = json.load(f)
-                    sources["tokenizer_config.json"] = data.get("chat_template", "")
-            except Exception as e:
-                sources["tokenizer_config.json"] = f"Error reading JSON: {e}"
-
-    if not sources:
-        print(f"{RED}❌ No template files found in {target}{RESET}")
-        print("Expected `chat_template.jinja`, `tokenizer_config.json`, or a `.gguf` file.\n")
-        sys.exit(1)
-
-    versions = {}
-    for name, content in sources.items():
-        ver = extract_template_version(content)
-        versions[name] = ver
-        status_color = GREEN if "froggeric" in ver else YELLOW
-        print(f"  [{name}]")
-        print(f"    Version detected: {status_color}{ver}{RESET}")
-        print(f"    Size: {len(content) if content else 0} characters")
-
-    # Check for mismatches
-    unique_versions = set(versions.values())
-    print("\n" + "-" * 50)
-
-    if len(sources) > 1 and len(unique_versions) > 1:
-        print(f"{YELLOW}⚠️  WARNING: TEMPLATE SOURCE MISMATCH DETECTED!{RESET}")
-        print("Your runtime may pick a different template depending on precedence:")
-        print("  - Transformers ≥ 4.51 / LM Studio: prefers `chat_template.jinja`")
-        print("  - oMLX / legacy engines: reads `tokenizer_config.json`")
-        print(f"\n{BOLD}Recommendation:{RESET} Overwrite both sources with `chat_template.jinja` and `chat_template_oneline.txt`.\n")
-        sys.exit(1)
-    else:
-        active_ver = list(unique_versions)[0]
-        if "froggeric-v22.3" in active_ver:
-            print(f"{GREEN}✅ SUCCESS: Verified v22.3 template is cleanly installed!{RESET}\n")
-            sys.exit(0)
-        elif "froggeric" in active_ver:
-            print(f"{CYAN}ℹ️  INFO: Found earlier fixed template version ({active_ver}). Upgrade to v22.3 recommended.{RESET}\n")
-            sys.exit(0)
-        else:
-            print(f"{YELLOW}⚠️  Stock / unpatched template detected.{RESET}\n")
-            sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

scripts/fuzz_template.py

@@ -1,290 +0,0 @@
-"""Deterministic property-based fuzzer for the fixed Qwen chat templates.
-
-Generates structurally valid conversations (system merging, multipart vision
-content, tool loops with mixed argument shapes, explicit and in-content
-reasoning, planted error payloads) and asserts nine invariants:
-
-  1. render          Rendering never raises on valid input.
-  2. parity          chat_template.jinja and chat_template_oneline.txt render
-                     byte-identically.
-  3. balance         <|im_start|> and <|im_end|> counts match
-                     (add_generation_prompt=False).
-  4. content         Planted user text, assistant answers, and (when preserved)
-                     reasoning appear verbatim in the output.
-  5. xml-fidelity    In XML mode every mapping tool-argument key appears as
-                     <parameter=key>; values appear verbatim when truncation
-                     is disabled.
-  6. json-validity   In JSON mode every emitted <tool_call> body parses as JSON.
-  7. warning         The tool-error warning appears iff an error payload was
-                     planted (no false positives, no false negatives).
-  8. prefix          render(messages[:k]) is a strict prefix of
-                     render(messages[:k+1]) at every generation boundary under
-                     default preserve_thinking. Prefixes that split a merged
-                     system block or a consecutive tool-result batch are
-                     skipped: those intermediate states are never rendered in
-                     real serving, where the model generates only after the
-                     full tool-result batch is appended.
-  9. prefill         enable_thinking=False ends the generation prompt with the
-                     empty think prefill.
-
-Usage:
-  python3 scripts/fuzz_template.py [--cases 500] [--seed 0] [--template chat_template.jinja]
-
-Exits nonzero on any invariant failure and prints a JSON repro for each.
-"""
-import argparse
-import json
-import os
-import random
-import sys
-import traceback
-
-from jinja2 import Environment, FileSystemLoader, StrictUndefined
-
-# Alphabet deliberately excludes every error-detector keyword, control-tag
-# fragment, and special-token prefix so invariant 7 stays two-sided.
-WORDS = ['alpha', 'bravo', 'delta', 'gamma', 'lumen', 'quartz', 'river',
-         'stone', 'matrix', 'vector', 'naïve', 'café', '数据', '結果']
-
-
-def _phrase(rnd, lo=2, hi=5):
-    sep = '\n' if rnd.random() < 0.1 else ' '
-    return sep.join(rnd.choice(WORDS) + str(rnd.randint(0, 99))
-                    for _ in range(rnd.randint(lo, hi)))
-
-
-def _gen_case(rnd):
-    kwargs = {}
-    fmt = 'json' if rnd.random() < 0.3 else 'xml'
-    if fmt == 'json':
-        kwargs['tool_call_format'] = 'json'
-    if rnd.random() < 0.3:
-        kwargs['reasoning_effort'] = rnd.choice(['low', 'medium', 'high', 'xhigh'])
-    no_think = rnd.random() < 0.15
-    if no_think:
-        kwargs['enable_thinking'] = False
-    preserve = True
-    if rnd.random() < 0.2:
-        kwargs['preserve_thinking'] = False
-        preserve = False
-    if rnd.random() < 0.2:
-        kwargs['add_vision_id'] = True
-    trunc_args = False
-    if fmt == 'xml' and rnd.random() < 0.2:
-        kwargs['max_tool_arg_chars'] = rnd.choice([8, 40])
-        trunc_args = True
-    if fmt == 'xml' and rnd.random() < 0.15:
-        kwargs['max_tool_response_chars'] = 80
-
-    msgs = []
-    user_texts, answers, reasonings, xml_keys, xml_vals = [], [], [], [], []
-    planted_error = False
-
-    for _ in range(rnd.randint(0, 2)):
-        msgs.append({'role': 'system', 'content': _phrase(rnd)})
-
-    for _ in range(rnd.randint(1, 3)):
-        text = _phrase(rnd)
-        if rnd.random() < 0.25:
-            parts = [{'type': 'image', 'image': 'x'}
-                     for _ in range(rnd.randint(1, 2))]
-            parts.append({'type': 'text', 'text': text})
-            msgs.append({'role': 'user', 'content': parts})
-        else:
-            msgs.append({'role': 'user', 'content': text})
-        user_texts.append(text)
-
-        for _ in range(rnd.randint(0, 2)):
-            calls = []
-            for c in range(rnd.randint(1, 2)):
-                roll = rnd.random()
-                if roll < 0.5:
-                    value = _phrase(rnd)
-                    args = {'k%d' % c: value}
-                    xml_keys.append('k%d' % c)
-                    if fmt == 'xml' and not trunc_args:
-                        xml_vals.append(value)
-                elif roll < 0.7:
-                    args = json.dumps({'q': _phrase(rnd)})
-                elif roll < 0.8:
-                    args = rnd.randint(0, 999)
-                elif roll < 0.9:
-                    args = [1, 2, 3]
-                else:
-                    args = {}
-                fn = {'name': 'fn%d' % c, 'arguments': args}
-                calls.append({'type': 'function', 'function': fn}
-                             if rnd.random() < 0.5 else dict(fn))
-            amsg = {'role': 'assistant',
-                    'content': _phrase(rnd) if rnd.random() < 0.4 else '',
-                    'tool_calls': calls}
-            if rnd.random() < 0.5:
-                rz = _phrase(rnd)
-                r_pick = rnd.random()
-                if r_pick < 0.34:
-                    amsg['content'] = '<think>\n' + rz + '\n</think>\n\n' + amsg['content']
-                elif r_pick < 0.67:
-                    amsg['reasoning_content'] = rz
-                else:
-                    amsg['reasoning'] = rz
-                if preserve:
-                    reasonings.append(rz)
-            msgs.append(amsg)
-            for _ in calls:
-                if rnd.random() < 0.12:
-                    msgs.append({'role': 'tool', 'content': '{"error": "boom"}'})
-                    planted_error = True
-                else:
-                    msgs.append({'role': 'tool', 'content': 'result ' + _phrase(rnd)})
-
-        ans = _phrase(rnd)
-        amsg = {'role': 'assistant', 'content': ans}
-        if rnd.random() < 0.6:
-            rz = _phrase(rnd)
-            r_pick = rnd.random()
-            if r_pick < 0.34:
-                amsg['content'] = '<think>\n' + rz + '\n</think>\n\n' + ans
-            elif r_pick < 0.67:
-                amsg['reasoning_content'] = rz
-            else:
-                amsg['reasoning'] = rz
-            if preserve:
-                reasonings.append(rz)
-        msgs.append(amsg)
-        answers.append(ans)
-
-    return dict(msgs=msgs, kwargs=kwargs, fmt=fmt, preserve=preserve,
-                no_think=no_think, user_texts=user_texts, answers=answers,
-                reasonings=reasonings, xml_keys=xml_keys, xml_vals=xml_vals,
-                planted_error=planted_error)
-
-
-def _check(case, tpl, other, failures, idx):
-    msgs, kw = case['msgs'], case['kwargs']
-
-    def fail(inv, detail):
-        failures.append({
-            'case': idx, 'invariant': inv, 'detail': detail,
-            'repro': json.dumps({'messages': msgs, 'kwargs': kw},
-                                ensure_ascii=False, default=str)})
-
-    try:
-        out = tpl.render(messages=msgs, add_generation_prompt=False, **kw)
-    except Exception:
-        fail('render', traceback.format_exc().strip().splitlines()[-1])
-        return
-    try:
-        out_b = other.render(messages=msgs, add_generation_prompt=False, **kw)
-        if out != out_b:
-            i = next((j for j in range(min(len(out), len(out_b)))
-                      if out[j] != out_b[j]), min(len(out), len(out_b)))
-            fail('parity', 'first diff at char %d: %r vs %r'
-                 % (i, out[i:i + 40], out_b[i:i + 40]))
-    except Exception:
-        fail('parity', traceback.format_exc().strip().splitlines()[-1])
-
-    if out.count('<|im_start|>') != out.count('<|im_end|>'):
-        fail('balance', '%d starts vs %d ends'
-             % (out.count('<|im_start|>'), out.count('<|im_end|>')))
-
-    for text in case['user_texts'] + case['answers'] + case['reasonings']:
-        if text not in out:
-            fail('content', 'missing %r' % text[:60])
-            break
-
-    if case['fmt'] == 'xml':
-        for key in case['xml_keys']:
-            if ('<parameter=%s>' % key) not in out:
-                fail('xml-fidelity', 'missing key %s' % key)
-                break
-        for value in case['xml_vals']:
-            if value not in out:
-                fail('xml-fidelity', 'missing value %r' % value[:60])
-                break
-
-    if case['fmt'] == 'json':
-        for block in out.split('<tool_call>\n')[1:]:
-            body = block.split('\n</tool_call>')[0]
-            try:
-                json.loads(body)
-            except Exception:
-                fail('json-validity', body[:80])
-                break
-
-    warned = '⚠️ SYSTEM WARNING' in out
-    if warned != case['planted_error']:
-        fail('warning', 'warned=%s planted=%s' % (warned, case['planted_error']))
-
-    if case['preserve']:
-        prev = None
-        for k in range(1, len(msgs) + 1):
-            if k < len(msgs) and msgs[k]['role'] == msgs[k - 1]['role'] \
-                    and msgs[k]['role'] in ('system', 'tool'):
-                continue
-            cur = tpl.render(messages=msgs[:k], add_generation_prompt=False, **kw)
-            
-            if k > 1 and msgs[k - 1].get('role') == 'assistant':
-                prompt = tpl.render(messages=msgs[:k - 1], add_generation_prompt=True, **kw)
-                if not cur.startswith(prompt):
-                    if prompt.endswith('<think>\n\n</think>\n\n') and cur.startswith(prompt[:-11]):
-                        # Fuzzer randomly injected reasoning into a non-thinking turn. KV cache naturally breaks here.
-                        pass
-                    else:
-                        fail('prefix', 'generation prompt at turn %d not prefix of history at turn %d' % (k - 1, k))
-                        break
-                    
-            if prev is not None and not cur.startswith(prev):
-                fail('prefix', 'history mutated at turn %d' % k)
-                break
-            prev = cur
-
-    if case['no_think']:
-        gen = tpl.render(messages=msgs, add_generation_prompt=True, **kw)
-        if not gen.endswith('<think>\n\n</think>\n\n'):
-            fail('prefill', repr(gen[-40:]))
-
-
-def run_fuzz(cases=500, seed=0, template_dir=None,
-             template_file='chat_template.jinja', max_failures=10):
-    template_dir = template_dir or os.path.dirname(
-        os.path.dirname(os.path.abspath(__file__)))
-    env = Environment(loader=FileSystemLoader(template_dir),
-                      undefined=StrictUndefined, keep_trailing_newline=True,
-                      lstrip_blocks=True, trim_blocks=True)
-    env.globals['raise_exception'] = \
-        lambda m: (_ for _ in ()).throw(Exception(m))
-    tpl = env.get_template(template_file)
-    other_name = ('chat_template.jinja'
-                  if template_file == 'chat_template_oneline.txt'
-                  else 'chat_template_oneline.txt')
-    other = env.get_template(other_name)
-    rnd = random.Random(seed)
-    failures = []
-    for i in range(cases):
-        _check(_gen_case(rnd), tpl, other, failures, i)
-        if len(failures) >= max_failures:
-            break
-    return failures
-
-
-def main():
-    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
-    parser.add_argument('--cases', type=int, default=500)
-    parser.add_argument('--seed', type=int, default=0)
-    parser.add_argument('--template', default='chat_template.jinja')
-    args = parser.parse_args()
-    failures = run_fuzz(cases=args.cases, seed=args.seed,
-                        template_file=args.template)
-    if failures:
-        for f in failures:
-            print('FAIL case %d [%s]: %s' % (f['case'], f['invariant'], f['detail']))
-            print('  repro: %s' % f['repro'][:800])
-        print('\n%d invariant violation(s) in %d cases (seed %d)'
-              % (len(failures), args.cases, args.seed))
-        sys.exit(1)
-    print('All invariants held over %d generated conversations (seed %d).'
-          % (args.cases, args.seed))
-
-
-if __name__ == '__main__':
-    main()

scripts/{test_v21.py → test_v20.py}

@@ -93,7 +93,7 @@ execute_test(
     messages=[{"role": "user", "content": "Hello!"}],
     tools=[{"name": "test_tool"}],
     kwargs={"auto_disable_thinking_with_tools": True},
-    expected_in=["<think>\n\n</think>\n\n"], # Should be stripped
+    expected_in=["<think>\n</think>\n"], # Should be stripped
 )
 
 execute_test(
@@ -120,7 +120,7 @@ execute_test(
     "max_tool_arg_chars truncation",
     messages=[{"role": "user", "content": "Call tool"}, {"role": "assistant", "content": "", "tool_calls": [{"function": {"name": "test", "arguments": {"param": "1234567890"}}}]}],
     kwargs={"max_tool_arg_chars": 5},
-    expected_in=["<parameter=param>\n12345\n[TRUNCATED"]
+    expected_in=["12345\n[TRUNCATED"]
 )
 
 execute_test(
@@ -141,7 +141,7 @@ execute_test(
 execute_test(
     "parallel tools delimiter",
     messages=[{"role": "user", "content": "x"}, {"role": "assistant", "content": "", "tool_calls": [{"name": "t1"}, {"name": "t2"}]}],
-    expected_in=["</function>\n</tool_call>\n\n<tool_call>\n<function=t2>"]
+    expected_in=["</tool_call>\n\n<tool_call>"]
 )
 
 # 6. Deep Agent Fallback
@@ -160,18 +160,7 @@ execute_test(
         {"role": "assistant", "content": "calling"},
         {"role": "tool", "content": "error: failed again"}
     ],
-    expected_in=["⚠️ SYSTEM WARNING: 2 consecutive tool errors", "<think>\n"]
-)
-
-run_test(
-    "tool_call_format='json' (override)",
-    messages=[{"role": "user", "content": "Call tool"}, {"role": "assistant", "content": "", "tool_calls": [{"function": {"name": "test", "arguments": {"par": "1234567890"}}}]}],
-    tools=[{"type": "function", "function": {"name": "test", "description": "test tool"}}],
-    kwargs={'tool_call_format': 'json'},
-    expected_in=[
-        'Function calls MUST follow the specified format: a single JSON object with "name" and "arguments"',
-        '{"name": "test", "arguments": {"par": "1234567890"}}'
-    ]
+    expected_in=["⚠️ SYSTEM WARNING: 2 consecutive tool errors", "<think>\n</think>\n"]
 )
 
 print(f"\n=============================")

scripts/test_v22.py

@@ -1,1740 +0,0 @@
-import os
-import sys
-import re
-import json
-import traceback
-
-try:
-    from jinja2 import Environment, FileSystemLoader, StrictUndefined
-except ImportError:
-    print("Error: jinja2 is required to run tests. Please install it using 'pip install jinja2'")
-    sys.exit(1)
-
-TEMPLATE_FILE = os.environ.get('QWEN_TEMPLATE_FILE', 'chat_template.jinja')
-TEMPLATE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-
-env = Environment(
-    loader=FileSystemLoader(TEMPLATE_DIR),
-    undefined=StrictUndefined,
-    keep_trailing_newline=True,
-    lstrip_blocks=True,
-    trim_blocks=True
-)
-
-def raise_exception(msg):
-    raise Exception(msg)
-
-env.globals['raise_exception'] = raise_exception
-
-try:
-    template = env.get_template(TEMPLATE_FILE)
-except Exception as e:
-    print(f"Error loading template: {e}")
-    sys.exit(1)
-
-def run_test(name, messages, tools=None, kwargs=None, expected_in=None, expected_not_in=None, expect_error=False):
-    if kwargs is None:
-        kwargs = {}
-    
-    print(f"\n--- Running Test: {name} ---")
-    
-    try:
-        render_kwargs = {'messages': messages, 'add_generation_prompt': True}
-        if tools is not None:
-            render_kwargs['tools'] = tools
-        render_kwargs.update(kwargs)
-        
-        rendered = template.render(**render_kwargs)
-        
-        if expect_error:
-            print("❌ FAILED: Expected an exception but got none.")
-            return False
-            
-        success = True
-        
-        if expected_in:
-            for ex in expected_in:
-                if ex not in rendered:
-                    print(f"❌ FAILED: Missing expected string:\n'''{ex}'''")
-                    print(f"Rendered:\n{rendered}")
-                    success = False
-        
-        if expected_not_in:
-            for n_ex in expected_not_in:
-                if n_ex in rendered:
-                    print(f"❌ FAILED: Found string that should NOT be present:\n'''{n_ex}'''")
-                    print(f"Rendered:\n{rendered}")
-                    success = False
-                    
-        if success:
-            print("✅ PASSED")
-            return True
-        return False
-        
-    except Exception as e:
-        if expect_error:
-            print(f"✅ PASSED (Caught expected error: {e})")
-            return True
-        print(f"❌ FAILED with exception:\n{traceback.format_exc()}")
-        return False
-
-def run_prefix_test(name, messages, kwargs=None):
-    """Asserts render(messages[:k]) is always a strict prefix of render(messages[:k+1]).
-
-    This is the direct verification of the 100% Prefix KV Cache claim: if any past turn
-    is mutated when a new turn arrives, the cached prefix is invalidated from that point.
-    """
-    if kwargs is None:
-        kwargs = {}
-
-    print(f"\n--- Running Test: {name} ---")
-
-    previous = None
-    for k in range(1, len(messages) + 1):
-        # Checkpoint only at generation boundaries: prefixes splitting a merged
-        # system block or a consecutive tool-result batch are never rendered in
-        # real serving, so they are not required to be stable.
-        if k < len(messages) and messages[k].get('role') == messages[k - 1].get('role') \
-                and messages[k].get('role') in ('system', 'tool'):
-            continue
-        try:
-            current = template.render(messages=messages[:k], add_generation_prompt=False, **kwargs)
-        except Exception:
-            print(f"❌ FAILED with exception:\n{traceback.format_exc()}")
-            return False
-
-        if previous is not None and not current.startswith(previous):
-            idx = min(len(previous), len(current))
-            for i in range(min(len(previous), len(current))):
-                if previous[i] != current[i]:
-                    idx = i
-                    break
-            print(f"❌ FAILED: turn {k} mutated rendered history at char {idx}.")
-            print(f"Before: {previous[max(0, idx - 80):idx + 80]!r}")
-            print(f"After:  {current[max(0, idx - 80):idx + 80]!r}")
-            return False
-        previous = current
-
-    print("✅ PASSED")
-    return True
-
-
-def run_oneline_parity_test(name, cases):
-    """Asserts chat_template_oneline.txt renders byte-identically to chat_template.jinja."""
-    print(f"\n--- Running Test: {name} ---")
-
-    oneline_path = os.path.join(TEMPLATE_DIR, 'chat_template_oneline.txt')
-    if not os.path.exists(oneline_path):
-        print(f"❌ FAILED: {oneline_path} not found.")
-        return False
-
-    with open(oneline_path, 'r', encoding='utf-8') as f:
-        oneline_source = f.read()
-    with open(os.path.join(TEMPLATE_DIR, TEMPLATE_FILE), 'r', encoding='utf-8') as f:
-        jinja_source = f.read()
-
-    version_pattern = r'template_version\s*=\s*["\']([^"\']+)["\']'
-    jinja_version = re.search(version_pattern, jinja_source)
-    oneline_version = re.search(version_pattern, oneline_source)
-    if not jinja_version or not oneline_version or jinja_version.group(1) != oneline_version.group(1):
-        print("❌ FAILED: template_version mismatch between jinja and oneline builds.")
-        print("Regenerate with: python3 scripts/minify_jinja.py chat_template.jinja chat_template_oneline.txt")
-        return False
-
-    oneline_template = env.from_string(oneline_source)
-
-    for label, messages, kwargs in cases:
-        try:
-            a = template.render(messages=messages, add_generation_prompt=True, **kwargs)
-            b = oneline_template.render(messages=messages, add_generation_prompt=True, **kwargs)
-        except Exception:
-            print(f"❌ FAILED with exception on case '{label}':\n{traceback.format_exc()}")
-            return False
-        if a != b:
-            print(f"❌ FAILED: oneline output diverges from jinja on case '{label}'.")
-            print("Regenerate with: python3 scripts/minify_jinja.py chat_template.jinja chat_template_oneline.txt")
-            return False
-
-    print("✅ PASSED")
-    return True
-
-
-tests_passed = 0
-tests_total = 0
-
-def execute_test(*args, **kwargs):
-    global tests_passed, tests_total
-    tests_total += 1
-    if run_test(*args, **kwargs):
-        tests_passed += 1
-
-def execute_prefix_test(*args, **kwargs):
-    global tests_passed, tests_total
-    tests_total += 1
-    if run_prefix_test(*args, **kwargs):
-        tests_passed += 1
-
-def execute_parity_test(*args, **kwargs):
-    global tests_passed, tests_total
-    tests_total += 1
-    if run_oneline_parity_test(*args, **kwargs):
-        tests_passed += 1
-
-# ==========================================
-# 1. Qwen 3.8 Reasoning Effort Controls (v22.1 Default: medium)
-# ==========================================
-
-# 1. Default reasoning_effort="medium" (no system message -> zero system message emitted)
-execute_test(
-    "1. reasoning_effort='medium' (v22.1 default, no system message)",
-    messages=[{"role": "user", "content": "Hello!"}],
-    expected_in=[
-        "<|im_start|>user\nHello!<|im_end|>\n<|im_start|>assistant\n<think>\n"
-    ],
-    expected_not_in=[
-        "<|im_start|>system\n"
-    ]
-)
-
-# 2. Explicit reasoning_effort="xhigh"
-execute_test(
-    "2. reasoning_effort='xhigh'",
-    messages=[{"role": "user", "content": "Hello!"}],
-    kwargs={"reasoning_effort": "xhigh"},
-    expected_in=[
-        "<|im_start|>system\nReasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.<|im_end|>\n",
-        "<|im_start|>user\nHello!<|im_end|>\n",
-        "<|im_start|>assistant\n<think>\n"
-    ]
-)
-
-# 3. Explicit reasoning_effort="high" (OpenAI alias -> xhigh)
-execute_test(
-    "3. reasoning_effort='high' (OpenAI alias)",
-    messages=[{"role": "user", "content": "Hello!"}],
-    kwargs={"reasoning_effort": "high"},
-    expected_in=[
-        "<|im_start|>system\nReasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.<|im_end|>\n"
-    ]
-)
-
-# 4. Explicit reasoning_effort="max" (API max alias -> xhigh)
-execute_test(
-    "4. reasoning_effort='max' (API alias)",
-    messages=[{"role": "user", "content": "Hello!"}],
-    kwargs={"reasoning_effort": "max"},
-    expected_in=[
-        "<|im_start|>system\nReasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.<|im_end|>\n"
-    ]
-)
-
-# 5. Explicit reasoning_effort="low"
-execute_test(
-    "5. reasoning_effort='low'",
-    messages=[{"role": "user", "content": "Hello!"}],
-    kwargs={"reasoning_effort": "low"},
-    expected_in=[
-        "<|im_start|>system\nReasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration.<|im_end|>\n",
-        "<|im_start|>user\nHello!<|im_end|>\n"
-    ]
-)
-
-# 6. Explicit reasoning_effort="minimal" (API minimal alias -> low)
-execute_test(
-    "6. reasoning_effort='minimal' (API alias)",
-    messages=[{"role": "user", "content": "Hello!"}],
-    kwargs={"reasoning_effort": "minimal"},
-    expected_in=[
-        "<|im_start|>system\nReasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration.<|im_end|>\n"
-    ]
-)
-
-# 7. Explicit reasoning_effort="none" (disables thinking)
-execute_test(
-    "7. reasoning_effort='none' (disables thinking)",
-    messages=[{"role": "user", "content": "Hello!"}],
-    kwargs={"reasoning_effort": "none"},
-    expected_in=[
-        "<|im_start|>user\nHello!<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n"
-    ],
-    expected_not_in=[
-        "Reasoning effort is set to"
-    ]
-)
-
-# 8. Explicit reasoning_effort="unknown_val" (safe fallback to medium)
-execute_test(
-    "8. reasoning_effort='unknown_val' (safe fallback to medium)",
-    messages=[{"role": "user", "content": "Hello!"}],
-    kwargs={"reasoning_effort": "unrecognized_str"},
-    expected_in=[
-        "<|im_start|>user\nHello!<|im_end|>\n<|im_start|>assistant\n<think>\n"
-    ],
-    expected_not_in=[
-        "Reasoning effort is set to"
-    ]
-)
-
-# 9. reasoning_effort='xhigh' with user system prompt
-execute_test(
-    "9. reasoning_effort='xhigh' with user system prompt",
-    messages=[
-        {"role": "system", "content": "You are an expert coder."},
-        {"role": "user", "content": "Write quicksort in C++"}
-    ],
-    kwargs={"reasoning_effort": "xhigh"},
-    expected_in=[
-        "<|im_start|>system\nReasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.\n\nYou are an expert coder.<|im_end|>\n",
-        "<|im_start|>user\nWrite quicksort in C++<|im_end|>\n"
-    ]
-)
-
-# 10. reasoning_effort='xhigh' with tools
-tools_sample = [
-    {
-        "type": "function",
-        "function": {
-            "name": "get_weather",
-            "description": "Get weather for city",
-            "parameters": {
-                "type": "object",
-                "properties": {"city": {"type": "string"}},
-                "required": ["city"]
-            }
-        }
-    }
-]
-
-execute_test(
-    "10. reasoning_effort='xhigh' with tools",
-    messages=[{"role": "user", "content": "What's the weather in Tokyo?"}],
-    tools=tools_sample,
-    kwargs={"reasoning_effort": "xhigh"},
-    expected_in=[
-        "<|im_start|>system\nReasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.\n\n# Tools\n\nYou have access to the following functions:\n\n<tools>\n"
-    ]
-)
-
-# ==========================================
-# 2. Inline Chat Tags for Reasoning Effort Steering (v22.1)
-# ==========================================
-
-# 11. Inline <|think_low|> in user message
-execute_test(
-    "11. Inline <|think_low|> in user string",
-    messages=[{"role": "user", "content": "What is 2+2? <|think_low|>"}],
-    expected_in=[
-        "<|im_start|>system\nReasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration.<|im_end|>\n",
-        "<|im_start|>user\nWhat is 2+2?<|im_end|>\n",
-        "<|im_start|>assistant\n<think>\n"
-    ],
-    expected_not_in=[
-        "<|think_low|>"
-    ]
-)
-
-# 12. Inline <|think_xhigh|> in user message
-execute_test(
-    "12. Inline <|think_xhigh|> in user string",
-    messages=[{"role": "user", "content": "Prove Fermat's Last Theorem <|think_xhigh|>"}],
-    expected_in=[
-        "<|im_start|>system\nReasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.<|im_end|>\n",
-        "<|im_start|>user\nProve Fermat's Last Theorem<|im_end|>\n",
-        "<|im_start|>assistant\n<think>\n"
-    ],
-    expected_not_in=[
-        "<|think_xhigh|>"
-    ]
-)
-
-# 13. Inline <|think_medium|> in user message
-execute_test(
-    "13. Inline <|think_medium|> in user string",
-    messages=[{"role": "user", "content": "Hello <|think_medium|>"}],
-    expected_in=[
-        "<|im_start|>user\nHello<|im_end|>\n",
-        "<|im_start|>assistant\n<think>\n"
-    ],
-    expected_not_in=[
-        "<|think_medium|>",
-        "<|im_start|>system\n"
-    ]
-)
-
-# 14. Inline <|think_off|> in user message
-execute_test(
-    "14. Inline <|think_off|> in user string",
-    messages=[{"role": "user", "content": "Quick answer: what is capital of France? <|think_off|>"}],
-    expected_in=[
-        "<|im_start|>user\nQuick answer: what is capital of France?<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n"
-    ],
-    expected_not_in=[
-        "<|think_off|>",
-        "Reasoning effort is set to"
-    ]
-)
-
-# 15. Inline <|think_low|> in multi-part list[dict]
-execute_test(
-    "15. Inline <|think_low|> in multi-part list[dict]",
-    messages=[
-        {"role": "user", "content": [{"type": "text", "text": "Solve this riddle <|think_low|>"}]}
-    ],
-    expected_in=[
-        "<|im_start|>system\nReasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration.<|im_end|>\n",
-        "<|im_start|>user\nSolve this riddle<|im_end|>\n"
-    ],
-    expected_not_in=[
-        "<|think_low|>"
-    ]
-)
-
-# 16. Inline <|think_xhigh|> in multi-part list[str]
-execute_test(
-    "16. Inline <|think_xhigh|> in multi-part list[str]",
-    messages=[
-        {"role": "user", "content": ["Solve this deeply", "<|think_xhigh|>"]}
-    ],
-    expected_in=[
-        "<|im_start|>system\nReasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.<|im_end|>\n",
-        "<|im_start|>user\nSolve this deeply<|im_end|>\n"
-    ],
-    expected_not_in=[
-        "<|think_xhigh|>"
-    ]
-)
-
-# 17. Clean tag stripping across multiple tags in same string
-execute_test(
-    "17. Clean tag stripping across multiple tags in same string",
-    messages=[
-        {"role": "user", "content": "Hello <|think_on|> <|think_minimal|> world"}
-    ],
-    expected_in=[
-        "<|im_start|>user\nHello   world<|im_end|>\n"
-    ],
-    expected_not_in=[
-        "<|think_on|>",
-        "<|think_minimal|>"
-    ]
-)
-
-# ==========================================
-# 3. Thinking Toggles & Preserves
-# ==========================================
-
-# 18. enable_thinking=false kwarg
-execute_test(
-    "18. enable_thinking=false kwarg",
-    messages=[{"role": "user", "content": "Hello!"}],
-    kwargs={"enable_thinking": False},
-    expected_in=[
-        "<|im_start|>user\nHello!<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n"
-    ]
-)
-
-# 19. auto_disable_thinking_with_tools=true
-execute_test(
-    "19. auto_disable_thinking_with_tools=true",
-    messages=[{"role": "user", "content": "What's the weather?"}],
-    tools=tools_sample,
-    kwargs={"auto_disable_thinking_with_tools": True},
-    expected_in=[
-        "<|im_start|>assistant\n<think>\n\n</think>\n\n"
-    ]
-)
-
-# 20. preserve_reasoning=True preserves thinking
-execute_test(
-    "20. preserve_reasoning=True preserves thinking",
-    messages=[
-        {"role": "user", "content": "Question 1"},
-        {"role": "assistant", "content": "<think>\nThinking 1\n</think>\n\nAnswer 1"},
-        {"role": "user", "content": "Question 2"}
-    ],
-    kwargs={"preserve_reasoning": True},
-    expected_in=[
-        "<|im_start|>assistant\n<think>\nThinking 1\n</think>\n\nAnswer 1<|im_end|>\n"
-    ]
-)
-
-# 21. preserve_reasoning=False strips past thinking
-execute_test(
-    "21. preserve_reasoning=False strips past thinking",
-    messages=[
-        {"role": "user", "content": "Question 1"},
-        {"role": "assistant", "content": "<think>\nThinking 1\n</think>\n\nAnswer 1"},
-        {"role": "user", "content": "Question 2"}
-    ],
-    kwargs={"preserve_reasoning": False},
-    expected_in=[
-        "<|im_start|>assistant\nAnswer 1<|im_end|>\n"
-    ],
-    expected_not_in=[
-        "Thinking 1"
-    ]
-)
-
-# 22. In-content <think> parsing (Curing official 3.8 empty think poisoning)
-execute_test(
-    "22. In-content <think> parsing (Curing official 3.8 empty think poisoning)",
-    messages=[
-        {"role": "user", "content": "Solve 1+1"},
-        {"role": "assistant", "content": "<think>\n1+1 is 2\n</think>\n\nResult is 2"},
-        {"role": "user", "content": "Now 2+2"}
-    ],
-    kwargs={"preserve_thinking": True},
-    expected_in=[
-        "<|im_start|>assistant\n<think>\n1+1 is 2\n</think>\n\nResult is 2<|im_end|>\n"
-    ],
-    expected_not_in=[
-        "<think>\n\n</think>\n\n<think>"
-    ]
-)
-
-# 23. OpenAI reasoning_content field
-execute_test(
-    "23. OpenAI reasoning_content field",
-    messages=[
-        {"role": "user", "content": "Question 1"},
-        {"role": "assistant", "content": "Answer 1", "reasoning_content": "Deep thought 1"},
-        {"role": "user", "content": "Question 2"}
-    ],
-    kwargs={"preserve_thinking": True},
-    expected_in=[
-        "<|im_start|>assistant\n<think>\nDeep thought 1\n</think>\n\nAnswer 1<|im_end|>\n"
-    ]
-)
-
-# 24. Anthropic message.thinking field
-execute_test(
-    "24. Anthropic message.thinking field",
-    messages=[
-        {"role": "user", "content": "Question 1"},
-        {"role": "assistant", "content": "Answer 1", "thinking": "Anthropic thought 1"},
-        {"role": "user", "content": "Question 2"}
-    ],
-    kwargs={"preserve_thinking": True},
-    expected_in=[
-        "<|im_start|>assistant\n<think>\nAnthropic thought 1\n</think>\n\nAnswer 1<|im_end|>\n"
-    ]
-)
-
-# 24b. OpenAI reasoning field (vLLM / Responses API name)
-execute_test(
-    "24b. OpenAI reasoning field (vLLM / Responses API name)",
-    messages=[
-        {"role": "user", "content": "Q1"},
-        {"role": "assistant", "content": "Answer 1", "reasoning": "Thought via reasoning field"},
-        {"role": "user", "content": "Q2"}
-    ],
-    expected_in=["<|im_start|>assistant\n<think>\nThought via reasoning field\n</think>\n\nAnswer 1<|im_end|>"]
-)
-
-# 24c. _default_reasoning_effort knob steers the no-kwarg default
-def run_default_effort_knob_test():
-    global tests_passed, tests_total
-    tests_total += 1
-    name = "24c. _default_reasoning_effort knob steers the no-kwarg default"
-    print(f"\n--- Running Test: {name} ---")
-    try:
-        src = open(os.path.join(TEMPLATE_DIR, TEMPLATE_FILE), encoding='utf-8').read()
-        assert src.count("_default_reasoning_effort = 'medium'") == 1, "knob line not found exactly once"
-        msgs = [{"role": "user", "content": "hi"}]
-        stock = env.from_string(src).render(messages=msgs, add_generation_prompt=True)
-        xhigh = env.from_string(src.replace("_default_reasoning_effort = 'medium'", "_default_reasoning_effort = 'xhigh'")).render(messages=msgs, add_generation_prompt=True)
-        off = env.from_string(src.replace("_default_reasoning_effort = 'medium'", "_default_reasoning_effort = 'none'")).render(messages=msgs, add_generation_prompt=True)
-        explicit = env.from_string(src.replace("_default_reasoning_effort = 'medium'", "_default_reasoning_effort = 'xhigh'")).render(messages=msgs, add_generation_prompt=True, reasoning_effort="low")
-        assert "Reasoning effort is set to" not in stock, "stock default must inject no steering line"
-        assert "Reasoning effort is set to xhigh" in xhigh, "xhigh knob must inject the xhigh line"
-        assert off.endswith("<think>\n\n</think>\n\n"), "none knob must disable thinking"
-        assert "Reasoning effort is set to low" in explicit, "an explicit kwarg must still override the knob"
-        print("✅ PASSED")
-        tests_passed += 1
-    except Exception as e:
-        print(f"❌ FAILED: {e}")
-run_default_effort_knob_test()
-
-# ==========================================
-# 4. Tool Calling (XML & JSON)
-# ==========================================
-
-# 25. Tool calling with dict arguments (XML)
-execute_test(
-    "25. Tool calling with dict arguments (XML)",
-    messages=[
-        {"role": "user", "content": "Weather in Paris?"},
-        {
-            "role": "assistant",
-            "content": "",
-            "tool_calls": [
-                {
-                    "type": "function",
-                    "function": {
-                        "name": "get_weather",
-                        "arguments": {"city": "Paris"}
-                    }
-                }
-            ]
-        }
-    ],
-    expected_in=[
-        "<|im_start|>assistant\n<think>\n\n</think>\n\n<tool_call>\n<function=get_weather>\n<parameter=city>\nParis\n</parameter>\n</function>\n</tool_call><|im_end|>\n"
-    ]
-)
-
-# 26. Tool calling with JSON string arguments (XML)
-execute_test(
-    "26. Tool calling with JSON string arguments (XML)",
-    messages=[
-        {"role": "user", "content": "Weather in Paris?"},
-        {
-            "role": "assistant",
-            "content": "",
-            "tool_calls": [
-                {
-                    "type": "function",
-                    "function": {
-                        "name": "get_weather",
-                        "arguments": '{"city": "Paris"}'
-                    }
-                }
-            ]
-        }
-    ],
-    kwargs={"tool_call_format": "xml"},
-    expected_in=[
-        "<|im_start|>assistant\n<think>\n\n</think>\n\n<tool_call>\n<function=get_weather>\n{\"city\": \"Paris\"}</function>\n</tool_call><|im_end|>\n"
-    ]
-)
-
-# 27. Tool calling with dict arguments (JSON format)
-execute_test(
-    "27. Tool calling with dict arguments (JSON format)",
-    messages=[
-        {"role": "user", "content": "Weather in Paris?"},
-        {
-            "role": "assistant",
-            "content": "",
-            "tool_calls": [
-                {
-                    "type": "function",
-                    "function": {
-                        "name": "get_weather",
-                        "arguments": {"city": "Paris"}
-                    }
-                }
-            ]
-        }
-    ],
-    kwargs={"tool_call_format": "json"},
-    expected_in=[
-        '<|im_start|>assistant\n<think>\n\n</think>\n\n<tool_call>\n{"name": "get_weather", "arguments": {"city": "Paris"}}\n</tool_call><|im_end|>\n'
-    ]
-)
-
-# 28. Tool calling with JSON string arguments (JSON format)
-execute_test(
-    "28. Tool calling with JSON string arguments (JSON format)",
-    messages=[
-        {"role": "user", "content": "Weather in Paris?"},
-        {
-            "role": "assistant",
-            "content": "",
-            "tool_calls": [
-                {
-                    "type": "function",
-                    "function": {
-                        "name": "get_weather",
-                        "arguments": '{"city": "Paris"}'
-                    }
-                }
-            ]
-        }
-    ],
-    kwargs={"tool_call_format": "json"},
-    expected_in=[
-        '<|im_start|>assistant\n<think>\n\n</think>\n\n<tool_call>\n{"name": "get_weather", "arguments": {"city": "Paris"}}\n</tool_call><|im_end|>\n'
-    ]
-)
-
-# 29. Tool calling with empty arguments string
-execute_test(
-    "29. Tool calling with empty arguments string",
-    messages=[
-        {"role": "user", "content": "Call tool without args"},
-        {
-            "role": "assistant",
-            "content": "",
-            "tool_calls": [
-                {
-                    "type": "function",
-                    "function": {
-                        "name": "no_arg_tool",
-                        "arguments": ""
-                    }
-                }
-            ]
-        }
-    ],
-    expected_in=[
-        "<|im_start|>assistant\n<think>\n\n</think>\n\n<tool_call>\n<function=no_arg_tool>\n</function>\n</tool_call><|im_end|>\n"
-    ]
-)
-
-# ==========================================
-# 5. Payload Truncation & Error Escalation
-# ==========================================
-
-# 30. Dynamic parameter truncation (max_tool_arg_chars)
-execute_test(
-    "30. Dynamic parameter truncation (max_tool_arg_chars)",
-    messages=[
-        {"role": "user", "content": "Execute SQL"},
-        {
-            "role": "assistant",
-            "content": "",
-            "tool_calls": [
-                {
-                    "type": "function",
-                    "function": {
-                        "name": "run_sql",
-                        "arguments": {"query": "SELECT * FROM users WHERE id = 1234567890 AND active = true"}
-                    }
-                }
-            ]
-        }
-    ],
-    kwargs={"max_tool_arg_chars": 20},
-    expected_in=[
-        "[TRUNCATED - original length"
-    ]
-)
-
-# 31. Dynamic response truncation (max_tool_response_chars)
-execute_test(
-    "31. Dynamic response truncation (max_tool_response_chars)",
-    messages=[
-        {"role": "user", "content": "Search files"},
-        {"role": "assistant", "content": "", "tool_calls": [{"type": "function", "function": {"name": "search", "arguments": {}}}]},
-        {"role": "tool", "content": "A" * 200}
-    ],
-    kwargs={"max_tool_response_chars": 50},
-    expected_in=[
-        "[TRUNCATED - original length 200 chars]"
-    ]
-)
-
-# 32. Consecutive tool error warning 1
-execute_test(
-    "32. Consecutive tool error warning 1",
-    messages=[
-        {"role": "user", "content": "Run tool"},
-        {"role": "assistant", "content": "", "tool_calls": [{"type": "function", "function": {"name": "run", "arguments": {}}}]},
-        {"role": "tool", "content": '{"error": "file not found"}'}
-    ],
-    expected_in=[
-        "⚠️ SYSTEM WARNING: The previous tool call returned an error. Diagnose the failure and retry with completely corrected arguments."
-    ]
-)
-
-# 33. Consecutive tool error warning 2 (retaining reasoning for error correction)
-execute_test(
-    "33. Consecutive tool error warning 2 (retaining reasoning for error correction)",
-    messages=[
-        {"role": "user", "content": "Run tool"},
-        {"role": "assistant", "content": "", "tool_calls": [{"type": "function", "function": {"name": "run", "arguments": {}}}]},
-        {"role": "tool", "content": '{"error": "file not found"}'},
-        {"role": "assistant", "content": "", "tool_calls": [{"type": "function", "function": {"name": "run", "arguments": {}}}]},
-        {"role": "tool", "content": '{"error": "permission denied"}'}
-    ],
-    expected_in=[
-        "⚠️ SYSTEM WARNING: 2 consecutive tool errors detected. Your previous approach is incorrect. You MUST use a fundamentally different approach or corrected arguments.",
-        "<|im_start|>assistant\n<think>\n"
-    ]
-)
-
-# 34. Mid-conversation system & developer messages
-execute_test(
-    "34. Mid-conversation system & developer messages",
-    messages=[
-        {"role": "user", "content": "Hello"},
-        {"role": "assistant", "content": "Hi"},
-        {"role": "developer", "content": "Mid-conversation update: user changed context."},
-        {"role": "user", "content": "Continue"}
-    ],
-    expected_in=[
-        "<|im_start|>system\nMid-conversation update: user changed context.<|im_end|>\n",
-        "<|im_start|>user\nContinue<|im_end|>\n"
-    ]
-)
-
-# ==========================================
-# 3. v22.2 Enhancements & Community Fixes
-# ==========================================
-
-# 35. reasoning_effort='ultracode' (Discussion #78)
-execute_test(
-    "35. reasoning_effort='ultracode'",
-    messages=[{"role": "user", "content": "Analyze algorithm"}],
-    kwargs={"reasoning_effort": "ultracode"},
-    expected_in=[
-        "<|im_start|>system\nReasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.<|im_end|>\n"
-    ]
-)
-
-# 36. reasoning_effort='extreme'
-execute_test(
-    "36. reasoning_effort='extreme'",
-    messages=[{"role": "user", "content": "Analyze algorithm"}],
-    kwargs={"reasoning_effort": "extreme"},
-    expected_in=[
-        "<|im_start|>system\nReasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.<|im_end|>\n"
-    ]
-)
-
-# 37. Inline <|think_ultracode|> in user message
-execute_test(
-    "37. Inline <|think_ultracode|> in user message",
-    messages=[{"role": "user", "content": "Optimize this shader <|think_ultracode|>"}],
-    expected_in=[
-        "<|im_start|>system\nReasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.<|im_end|>\n",
-        "<|im_start|>user\nOptimize this shader<|im_end|>\n"
-    ],
-    expected_not_in=[
-        "<|think_ultracode|>"
-    ]
-)
-
-# 38. Multiple leading system and developer messages merging
-execute_test(
-    "38. Multiple leading system and developer messages merging",
-    messages=[
-        {"role": "system", "content": "Base instructions."},
-        {"role": "developer", "content": "Developer constraints."},
-        {"role": "system", "content": "Additional guidelines."},
-        {"role": "user", "content": "Hello"}
-    ],
-    expected_in=[
-        "<|im_start|>system\nBase instructions.\n\nDeveloper constraints.\n\nAdditional guidelines.<|im_end|>\n",
-        "<|im_start|>user\nHello<|im_end|>\n"
-    ]
-)
-
-# 39. Grep code search with throw Error not false-positiving on tool error (Discussion #66)
-execute_test(
-    "39. Grep code search with throw Error not false-positiving on tool error (Discussion #66)",
-    messages=[
-        {"role": "user", "content": "Search for error handlers"},
-        {"role": "assistant", "content": "", "tool_calls": [{"type": "function", "function": {"name": "grep", "arguments": {"pattern": "failed to"}}}]},
-        {"role": "tool", "content": "src/lib/api.ts:42: throw new Error('failed to fetch');"},
-        {"role": "assistant", "content": "", "tool_calls": [{"type": "function", "function": {"name": "grep", "arguments": {"pattern": "failed to"}}}]},
-        {"role": "tool", "content": "src/lib/auth.ts:18: throw new Error('failed to authenticate');"}
-    ],
-    expected_not_in=[
-        "⚠️ SYSTEM WARNING"
-    ]
-)
-
-# 40. Grep code search with console.error not false-positiving
-execute_test(
-    "40. Grep code search with console.error not false-positiving",
-    messages=[
-        {"role": "user", "content": "Search for error logging"},
-        {"role": "assistant", "content": "", "tool_calls": [{"type": "function", "function": {"name": "grep", "arguments": {"pattern": "console.error"}}}]},
-        {"role": "tool", "content": "src/utils.js:5: console.error('failed to load config');"}
-    ],
-    expected_not_in=[
-        "⚠️ SYSTEM WARNING"
-    ]
-)
-
-# 41. Python Traceback legitimately triggers tool error warning
-execute_test(
-    "41. Python Traceback legitimately triggers tool error warning",
-    messages=[
-        {"role": "user", "content": "Run script"},
-        {"role": "assistant", "content": "", "tool_calls": [{"type": "function", "function": {"name": "python", "arguments": {"code": "1/0"}}}]},
-        {"role": "tool", "content": "Traceback (most recent call last):\n  File 'test.py', line 1\nZeroDivisionError: division by zero"}
-    ],
-    expected_in=[
-        "⚠️ SYSTEM WARNING: The previous tool call returned an error. Diagnose the failure and retry with completely corrected arguments."
-    ]
-)
-
-# 42. Safe XML parameter formatting for booleans, nulls, and numbers
-execute_test(
-    "42. Safe XML parameter formatting for booleans, nulls, and numbers",
-    messages=[
-        {"role": "user", "content": "Call config tool"},
-        {"role": "assistant", "content": "", "tool_calls": [{
-            "type": "function",
-            "function": {
-                "name": "set_config",
-                "arguments": {
-                    "is_active": True,
-                    "is_debug": False,
-                    "retries": 5,
-                    "metadata": None
-                }
-            }
-        }]}
-    ],
-    expected_in=[
-        "<parameter=is_active>\ntrue\n</parameter>",
-        "<parameter=is_debug>\nfalse\n</parameter>",
-        "<parameter=retries>\n5\n</parameter>",
-        "<parameter=metadata>\nnull\n</parameter>"
-    ]
-)
-
-# 43. KV Cache Stability: History with JSON string arguments preserves canonical XML system prompt
-execute_test(
-    "43. KV Cache Stability: History with JSON string arguments preserves canonical XML system prompt",
-    messages=[
-        {"role": "user", "content": "What's the weather?"},
-        {"role": "assistant", "content": "", "tool_calls": [{
-            "type": "function",
-            "function": {
-                "name": "get_weather",
-                "arguments": '{"city": "Paris", "unit": "celsius"}'
-            }
-        }]},
-        {"role": "tool", "content": '{"temp": 22}'}
-    ],
-    tools=tools_sample,
-    expected_in=[
-        "<function=example_function_name>",
-        "<tool_call>\n<function=get_weather>\n{\"city\": \"Paris\", \"unit\": \"celsius\"}</function>\n</tool_call>"
-    ]
-)
-
-# ==========================================
-# 6. Control Tag & Alias Completeness (v22.3)
-# ==========================================
-
-# 45. Inline <|think_high|>
-execute_test(
-    "45. Inline <|think_high|>",
-    messages=[{"role": "user", "content": "Analyze this <|think_high|>"}],
-    expected_in=[
-        "<|im_start|>system\nReasoning effort is set to xhigh."
-    ],
-    expected_not_in=[
-        "<|think_high|>"
-    ]
-)
-
-# 46. Inline <|think_extreme|>
-execute_test(
-    "46. Inline <|think_extreme|>",
-    messages=[{"role": "user", "content": "Analyze this <|think_extreme|>"}],
-    expected_in=[
-        "<|im_start|>system\nReasoning effort is set to xhigh."
-    ],
-    expected_not_in=[
-        "<|think_extreme|>"
-    ]
-)
-
-# 47. Inline <|think_max|>
-execute_test(
-    "47. Inline <|think_max|>",
-    messages=[{"role": "user", "content": "Analyze this <|think_max|>"}],
-    expected_in=[
-        "<|im_start|>system\nReasoning effort is set to xhigh."
-    ],
-    expected_not_in=[
-        "<|think_max|>"
-    ]
-)
-
-# 48. Inline <|think_minimal|> injects low reasoning instructions
-execute_test(
-    "48. Inline <|think_minimal|> injects low reasoning instructions",
-    messages=[{"role": "user", "content": "Answer fast <|think_minimal|>"}],
-    expected_in=[
-        "<|im_start|>system\nReasoning effort is set to low."
-    ],
-    expected_not_in=[
-        "<|think_minimal|>"
-    ]
-)
-
-# 49. Inline <|think_on|> overrides enable_thinking=False
-execute_test(
-    "49. Inline <|think_on|> overrides enable_thinking=False",
-    messages=[{"role": "user", "content": "Think about this <|think_on|>"}],
-    kwargs={"enable_thinking": False},
-    expected_in=[
-        "<|im_start|>assistant\n<think>\n"
-    ],
-    expected_not_in=[
-        "<think>\n\n</think>",
-        "<|think_on|>"
-    ]
-)
-
-# 50. reasoning_effort is case-insensitive
-execute_test(
-    "50. reasoning_effort is case-insensitive",
-    messages=[{"role": "user", "content": "Hello!"}],
-    kwargs={"reasoning_effort": "XHigh"},
-    expected_in=[
-        "<|im_start|>system\nReasoning effort is set to xhigh."
-    ]
-)
-
-# 51. reasoning_effort='off' disables thinking
-execute_test(
-    "51. reasoning_effort='off' disables thinking",
-    messages=[{"role": "user", "content": "Hello!"}],
-    kwargs={"reasoning_effort": "off"},
-    expected_in=[
-        "<|im_start|>assistant\n<think>\n\n</think>\n\n"
-    ],
-    expected_not_in=[
-        "Reasoning effort is set to"
-    ]
-)
-
-# 52. reasoning_effort=None falls back to medium
-execute_test(
-    "52. reasoning_effort=None falls back to medium",
-    messages=[{"role": "user", "content": "Hello!"}],
-    kwargs={"reasoning_effort": None},
-    expected_in=[
-        "<|im_start|>assistant\n<think>\n"
-    ],
-    expected_not_in=[
-        "Reasoning effort is set to"
-    ]
-)
-
-# 53. Non-string reasoning_effort does not crash
-execute_test(
-    "53. Non-string reasoning_effort does not crash",
-    messages=[{"role": "user", "content": "Hello!"}],
-    kwargs={"reasoning_effort": 3},
-    expected_in=[
-        "<|im_start|>assistant\n<think>\n"
-    ],
-    expected_not_in=[
-        "Reasoning effort is set to"
-    ]
-)
-
-# 54. Control tag inside a system message is honored and stripped
-execute_test(
-    "54. Control tag inside a system message is honored and stripped",
-    messages=[
-        {"role": "system", "content": "You are terse. <|think_low|>"},
-        {"role": "user", "content": "Hello"}
-    ],
-    expected_in=[
-        "Reasoning effort is set to low.",
-        "You are terse."
-    ],
-    expected_not_in=[
-        "<|think_low|>"
-    ]
-)
-
-# 55. Most recent control tag wins across turns
-execute_test(
-    "55. Most recent control tag wins across turns",
-    messages=[
-        {"role": "user", "content": "First <|think_xhigh|>"},
-        {"role": "assistant", "content": "Ok"},
-        {"role": "user", "content": "Second <|think_low|>"}
-    ],
-    expected_in=[
-        "Reasoning effort is set to low."
-    ],
-    expected_not_in=[
-        "Reasoning effort is set to xhigh."
-    ]
-)
-
-# 56. enable_thinking=False suppresses reasoning effort injection
-execute_test(
-    "56. enable_thinking=False suppresses reasoning effort injection",
-    messages=[{"role": "user", "content": "Hello!"}],
-    kwargs={"enable_thinking": False, "reasoning_effort": "xhigh"},
-    expected_in=[
-        "<|im_start|>assistant\n<think>\n\n</think>\n\n"
-    ],
-    expected_not_in=[
-        "Reasoning effort is set to"
-    ]
-)
-
-# 57. <|think_off|> takes precedence over an effort tag in the same message
-execute_test(
-    "57. <|think_off|> takes precedence over an effort tag in the same message",
-    messages=[{"role": "user", "content": "Quick <|think_xhigh|> <|think_off|>"}],
-    expected_in=[
-        "<|im_start|>assistant\n<think>\n\n</think>\n\n"
-    ],
-    expected_not_in=[
-        "Reasoning effort is set to",
-        "<|think_"
-    ]
-)
-
-# ==========================================
-# 7. Malformed Input & Exception Paths (v22.3)
-# ==========================================
-
-# 58. Empty message list raises
-execute_test(
-    "58. Empty message list raises",
-    messages=[],
-    expect_error=True
-)
-
-# 59. Image inside a leading system message raises
-execute_test(
-    "59. Image inside a leading system message raises",
-    messages=[
-        {"role": "system", "content": [{"type": "image", "image": "data"}]},
-        {"role": "user", "content": "Hello"}
-    ],
-    expect_error=True
-)
-
-# 60. Scalar (non-string, non-list) content raises
-execute_test(
-    "60. Scalar content raises",
-    messages=[{"role": "user", "content": 12345}],
-    expect_error=True
-)
-
-# 61. Unknown multi-part item type raises
-execute_test(
-    "61. Unknown multi-part item type raises",
-    messages=[{"role": "user", "content": [{"type": "audio", "audio": "data"}]}],
-    expect_error=True
-)
-
-# ==========================================
-# 8. Vision & Multi-Part Content (v22.3)
-# ==========================================
-
-# 62. Image part renders vision tokens inline with text
-execute_test(
-    "62. Image part renders vision tokens inline with text",
-    messages=[{"role": "user", "content": [
-        {"type": "image", "image": "data"},
-        {"type": "text", "text": "What is this?"}
-    ]}],
-    expected_in=[
-        "<|im_start|>user\n<|vision_start|><|image_pad|><|vision_end|>What is this?<|im_end|>\n"
-    ]
-)
-
-# 63. add_vision_id numbers images across turns
-execute_test(
-    "63. add_vision_id numbers images across turns",
-    messages=[
-        {"role": "user", "content": [{"type": "image", "image": "a"}]},
-        {"role": "assistant", "content": "Ok"},
-        {"role": "user", "content": [{"type": "image", "image": "b"}]}
-    ],
-    kwargs={"add_vision_id": True},
-    expected_in=[
-        "Picture 1: <|vision_start|><|image_pad|><|vision_end|>",
-        "Picture 2: <|vision_start|><|image_pad|><|vision_end|>"
-    ]
-)
-
-# 64. Video part renders video tokens
-execute_test(
-    "64. Video part renders video tokens",
-    messages=[{"role": "user", "content": [{"type": "video", "video": "data"}]}],
-    expected_in=[
-        "<|vision_start|><|video_pad|><|vision_end|>"
-    ]
-)
-
-# ==========================================
-# 9. Agentic Structure & Wire Format Shapes (v22.3)
-# ==========================================
-
-# 65. Assistant text combined with a tool call
-execute_test(
-    "65. Assistant text combined with a tool call",
-    messages=[
-        {"role": "user", "content": "Weather?"},
-        {"role": "assistant", "content": "Let me check.", "tool_calls": [
-            {"type": "function", "function": {"name": "get_weather", "arguments": {"city": "Paris"}}}
-        ]}
-    ],
-    expected_in=[
-        "<|im_start|>assistant\n<think>\n\n</think>\n\nLet me check.\n\n<tool_call>\n<function=get_weather>\n"
-    ]
-)
-
-# 66. Parallel tool calls in a single assistant message
-execute_test(
-    "66. Parallel tool calls in a single assistant message",
-    messages=[
-        {"role": "user", "content": "Compare"},
-        {"role": "assistant", "content": "", "tool_calls": [
-            {"type": "function", "function": {"name": "f1", "arguments": {"a": "1"}}},
-            {"type": "function", "function": {"name": "f2", "arguments": {"b": "2"}}}
-        ]}
-    ],
-    expected_in=[
-        "<|im_start|>assistant\n<think>\n\n</think>\n\n<tool_call>\n<function=f1>\n",
-        "</tool_call>\n<tool_call>\n<function=f2>\n"
-    ]
-)
-
-# 67. Consecutive tool results collapse into a single user turn
-execute_test(
-    "67. Consecutive tool results collapse into a single user turn",
-    messages=[
-        {"role": "user", "content": "Compare"},
-        {"role": "assistant", "content": "", "tool_calls": [
-            {"type": "function", "function": {"name": "f1", "arguments": {}}},
-            {"type": "function", "function": {"name": "f2", "arguments": {}}}
-        ]},
-        {"role": "tool", "content": "result one"},
-        {"role": "tool", "content": "result two"},
-        {"role": "user", "content": "Thanks"}
-    ],
-    expected_in=[
-        "<|im_start|>user\n<tool_response>\nresult one\n</tool_response>\n<tool_response>\nresult two\n</tool_response><|im_end|>\n"
-    ]
-)
-
-# 68. Flat tool_call shape without a 'function' wrapper
-execute_test(
-    "68. Flat tool_call shape without a 'function' wrapper",
-    messages=[
-        {"role": "user", "content": "Weather?"},
-        {"role": "assistant", "content": "", "tool_calls": [
-            {"name": "get_weather", "arguments": {"city": "Paris"}}
-        ]}
-    ],
-    expected_in=[
-        "<tool_call>\n<function=get_weather>\n<parameter=city>\nParis\n</parameter>\n</function>\n</tool_call>"
-    ]
-)
-
-# 69. OpenAI tool_call id/index fields are tolerated
-execute_test(
-    "69. OpenAI tool_call id/index fields are tolerated",
-    messages=[
-        {"role": "user", "content": "Weather?"},
-        {"role": "assistant", "content": "", "tool_calls": [
-            {"id": "call_abc", "index": 0, "type": "function",
-             "function": {"name": "get_weather", "arguments": {"city": "Paris"}}}
-        ]},
-        {"role": "tool", "tool_call_id": "call_abc", "content": "22C"}
-    ],
-    expected_in=[
-        "<function=get_weather>",
-        "<tool_response>\n22C\n</tool_response>"
-    ]
-)
-
-# 70. Unknown roles fall back to a labelled user turn
-execute_test(
-    "70. Unknown roles fall back to a labelled user turn",
-    messages=[
-        {"role": "user", "content": "Hello"},
-        {"role": "critic", "content": "Needs work"}
-    ],
-    expected_in=[
-        "<|im_start|>user\n[critic]: Needs work<|im_end|>\n"
-    ]
-)
-
-# 71. add_generation_prompt=False emits no assistant header
-execute_test(
-    "71. add_generation_prompt=False emits no assistant header",
-    messages=[{"role": "user", "content": "Hello"}],
-    kwargs={"add_generation_prompt": False},
-    expected_in=[
-        "<|im_start|>user\nHello<|im_end|>\n"
-    ],
-    expected_not_in=[
-        "<|im_start|>assistant"
-    ]
-)
-
-# 72. Empty tools list emits no tool system block
-execute_test(
-    "72. Empty tools list emits no tool system block",
-    messages=[{"role": "user", "content": "Hello"}],
-    tools=[],
-    expected_not_in=[
-        "# Tools"
-    ]
-)
-
-# 73. Assistant content=None does not crash
-execute_test(
-    "73. Assistant content=None does not crash",
-    messages=[
-        {"role": "user", "content": "Hi"},
-        {"role": "assistant", "content": None},
-        {"role": "user", "content": "Again"}
-    ],
-    expected_in=[
-        "<|im_start|>assistant\n<think>\n\n</think>\n\n<|im_end|>\n"
-    ]
-)
-
-# 74. Scalar tool arguments are serialized, not dropped
-execute_test(
-    "74. Scalar tool arguments are serialized, not dropped",
-    messages=[
-        {"role": "user", "content": "Call"},
-        {"role": "assistant", "content": "", "tool_calls": [
-            {"type": "function", "function": {"name": "f", "arguments": 42}}
-        ]}
-    ],
-    expected_in=[
-        "<tool_call>\n<function=f>\n42</function>\n</tool_call>"
-    ]
-)
-
-# ==========================================
-# 10. Reasoning Extraction Edge Cases (v22.3)
-# ==========================================
-
-# 75. <thinking> variant is extracted and normalized
-execute_test(
-    "75. <thinking> variant is extracted and normalized",
-    messages=[
-        {"role": "user", "content": "Q"},
-        {"role": "assistant", "content": "<thinking>\nT\n</thinking>\n\nA"},
-        {"role": "user", "content": "Q2"}
-    ],
-    expected_in=[
-        "<|im_start|>assistant\n<think>\nT\n</think>\n\nA<|im_end|>\n"
-    ]
-)
-
-# 76. Spaced </think > variant is extracted
-execute_test(
-    "76. Spaced </think > variant is extracted",
-    messages=[
-        {"role": "user", "content": "Q"},
-        {"role": "assistant", "content": "<think>\nT\n</think >\n\nA"},
-        {"role": "user", "content": "Q2"}
-    ],
-    expected_in=[
-        "<|im_start|>assistant\n<think>\nT\n</think>\n\nA<|im_end|>\n"
-    ]
-)
-
-# 77. Single-line think block is extracted
-execute_test(
-    "77. Single-line think block is extracted",
-    messages=[
-        {"role": "user", "content": "Q"},
-        {"role": "assistant", "content": "<think>T</think>A"},
-        {"role": "user", "content": "Q2"}
-    ],
-    expected_in=[
-        "<|im_start|>assistant\n<think>\nT\n</think>\n\nA<|im_end|>\n"
-    ]
-)
-
-# 78. reasoning_content plus in-content tags must not duplicate think blocks
-execute_test(
-    "78. reasoning_content plus in-content tags must not duplicate think blocks",
-    messages=[
-        {"role": "user", "content": "Q"},
-        {"role": "assistant", "reasoning_content": "R", "content": "<think>\nT\n</think>\n\nA"},
-        {"role": "user", "content": "Q2"}
-    ],
-    expected_in=[
-        "<|im_start|>assistant\n<think>\nR\n</think>\n\nA<|im_end|>\n"
-    ],
-    expected_not_in=[
-        "</think>\n\n<think>"
-    ]
-)
-
-# 79. preserve_thinking=False retains reasoning inside the active tool loop
-execute_test(
-    "79. preserve_thinking=False retains reasoning inside the active tool loop",
-    messages=[
-        {"role": "user", "content": "Fix it"},
-        {"role": "assistant", "content": "<think>\nplan the fix\n</think>\n\n", "tool_calls": [
-            {"type": "function", "function": {"name": "run", "arguments": {}}}
-        ]},
-        {"role": "tool", "content": "output"}
-    ],
-    kwargs={"preserve_thinking": False},
-    expected_in=[
-        "plan the fix"
-    ]
-)
-
-# 80. preserve_thinking=False strips reasoning once a new user turn starts
-execute_test(
-    "80. preserve_thinking=False strips reasoning once a new user turn starts",
-    messages=[
-        {"role": "user", "content": "Fix it"},
-        {"role": "assistant", "content": "<think>\nplan the fix\n</think>\n\n", "tool_calls": [
-            {"type": "function", "function": {"name": "run", "arguments": {}}}
-        ]},
-        {"role": "tool", "content": "output"},
-        {"role": "assistant", "content": "<think>\nwrap up\n</think>\n\nDone."},
-        {"role": "user", "content": "Thanks"}
-    ],
-    kwargs={"preserve_thinking": False},
-    expected_not_in=[
-        "plan the fix",
-        "wrap up"
-    ]
-)
-
-# 81. Explicit reasoning preserves literal think tags inside the final answer
-execute_test(
-    "81. Explicit reasoning preserves literal think tags inside the final answer",
-    messages=[
-        {"role": "user", "content": "How do I close the think block?"},
-        {"role": "assistant", "reasoning_content": "R",
-         "content": "Use this closing tag:\n```\n</think>\n```\nDone."},
-        {"role": "user", "content": "thanks"}
-    ],
-    expected_in=[
-        "<|im_start|>assistant\n<think>\nR\n</think>\n\nUse this closing tag:\n```\n</think>\n```\nDone.<|im_end|>\n"
-    ]
-)
-
-# ==========================================
-# 11. Tool Error Detection Precision (v22.3)
-# ==========================================
-
-# 82. Structural error signal fires regardless of payload length
-execute_test(
-    "82. Structural error signal fires regardless of payload length",
-    messages=[
-        {"role": "user", "content": "Run"},
-        {"role": "assistant", "content": "", "tool_calls": [{"type": "function", "function": {"name": "f", "arguments": {}}}]},
-        {"role": "tool", "content": '{"error": "boom"}\n' + "detail line\n" * 80}
-    ],
-    expected_in=[
-        "⚠️ SYSTEM WARNING: The previous tool call returned an error."
-    ]
-)
-
-# 83. Long traceback beyond the weak-signal length gate still fires
-execute_test(
-    "83. Long traceback beyond the weak-signal length gate still fires",
-    messages=[
-        {"role": "user", "content": "Run"},
-        {"role": "assistant", "content": "", "tool_calls": [{"type": "function", "function": {"name": "f", "arguments": {}}}]},
-        {"role": "tool", "content": "Traceback (most recent call last):\n" +
-            '  File "/app/handler.py", line 118, in process\n    result = self.client.fetch(payload)\n' * 6 +
-            "ConnectionResetError: [Errno 104] Connection reset by peer"}
-    ],
-    expected_in=[
-        "⚠️ SYSTEM WARNING: The previous tool call returned an error."
-    ]
-)
-
-# 84. Shell-echoed command output still reports a real failure
-execute_test(
-    "84. Shell-echoed command output still reports a real failure",
-    messages=[
-        {"role": "user", "content": "Build"},
-        {"role": "assistant", "content": "", "tool_calls": [{"type": "function", "function": {"name": "bash", "arguments": {}}}]},
-        {"role": "tool", "content": "$ npm run build\nError: command not found"}
-    ],
-    expected_in=[
-        "⚠️ SYSTEM WARNING: The previous tool call returned an error."
-    ]
-)
-
-# 85. Timing metadata does not suppress a structural error
-execute_test(
-    "85. Timing metadata does not suppress a structural error",
-    messages=[
-        {"role": "user", "content": "Query"},
-        {"role": "assistant", "content": "", "tool_calls": [{"type": "function", "function": {"name": "db", "arguments": {}}}]},
-        {"role": "tool", "content": '{"error": "db timeout", "note": "took 3ms"}'}
-    ],
-    expected_in=[
-        "⚠️ SYSTEM WARNING: The previous tool call returned an error."
-    ]
-)
-
-# 86. Successful exit code report does not trigger an error warning
-execute_test(
-    "86. Successful exit code report does not trigger an error warning",
-    messages=[
-        {"role": "user", "content": "Run"},
-        {"role": "assistant", "content": "", "tool_calls": [{"type": "function", "function": {"name": "bash", "arguments": {}}}]},
-        {"role": "tool", "content": "Command completed successfully.\nExit code: 0\n" + "log line\n" * 40}
-    ],
-    expected_not_in=[
-        "⚠️ SYSTEM WARNING"
-    ]
-)
-
-# 87. Nonzero exit code escalates regardless of payload length
-execute_test(
-    "87. Nonzero exit code escalates regardless of payload length",
-    messages=[
-        {"role": "user", "content": "Run"},
-        {"role": "assistant", "content": "", "tool_calls": [{"type": "function", "function": {"name": "bash", "arguments": {}}}]},
-        {"role": "tool", "content": "Exit code: 1\n" + "stack frame\n" * 60}
-    ],
-    expected_in=[
-        "⚠️ SYSTEM WARNING: The previous tool call returned an error."
-    ]
-)
-
-# 88. Failure counter resets after a successful call
-execute_test(
-    "88. Failure counter resets after a successful call",
-    messages=[
-        {"role": "user", "content": "Run"},
-        {"role": "assistant", "content": "", "tool_calls": [{"type": "function", "function": {"name": "f", "arguments": {}}}]},
-        {"role": "tool", "content": '{"error": "e1"}'},
-        {"role": "assistant", "content": "", "tool_calls": [{"type": "function", "function": {"name": "f", "arguments": {}}}]},
-        {"role": "tool", "content": '{"ok": true}'},
-        {"role": "assistant", "content": "", "tool_calls": [{"type": "function", "function": {"name": "f", "arguments": {}}}]},
-        {"role": "tool", "content": '{"error": "e2"}'}
-    ],
-    expected_not_in=[
-        "2 consecutive tool errors"
-    ]
-)
-
-# 89. Failure counter resets on a new user turn
-execute_test(
-    "89. Failure counter resets on a new user turn",
-    messages=[
-        {"role": "user", "content": "Run"},
-        {"role": "assistant", "content": "", "tool_calls": [{"type": "function", "function": {"name": "f", "arguments": {}}}]},
-        {"role": "tool", "content": '{"error": "e1"}'},
-        {"role": "user", "content": "Try again"},
-        {"role": "assistant", "content": "", "tool_calls": [{"type": "function", "function": {"name": "f", "arguments": {}}}]},
-        {"role": "tool", "content": '{"error": "e2"}'}
-    ],
-    expected_not_in=[
-        "2 consecutive tool errors"
-    ]
-)
-
-# 90. Tool response truncation is bypassed in JSON format
-execute_test(
-    "90. Tool response truncation is bypassed in JSON format",
-    messages=[
-        {"role": "user", "content": "Query"},
-        {"role": "assistant", "content": "", "tool_calls": [{"type": "function", "function": {"name": "f", "arguments": {}}}]},
-        {"role": "tool", "content": json.dumps({"rows": ["x"] * 200})}
-    ],
-    kwargs={"tool_call_format": "json", "max_tool_response_chars": 50},
-    expected_not_in=[
-        "[TRUNCATED"
-    ]
-)
-
-# 91. max_tool_arg_chars applies to serialized JSON string arguments
-execute_test(
-    "91. max_tool_arg_chars applies to serialized JSON string arguments",
-    messages=[
-        {"role": "user", "content": "Query"},
-        {"role": "assistant", "content": "", "tool_calls": [
-            {"type": "function", "function": {"name": "f", "arguments": json.dumps({"q": "S" * 400})}}
-        ]}
-    ],
-    kwargs={"max_tool_arg_chars": 20},
-    expected_in=[
-        "[TRUNCATED - original length"
-    ]
-)
-
-# ==========================================
-# 12. KV Cache Prefix Stability & Build Parity (v22.3)
-# ==========================================
-
-agentic_session = [
-    {"role": "system", "content": "You are a coding agent."},
-    {"role": "user", "content": "Fix the build"},
-    {"role": "assistant", "content": "<think>\ninspect the logs\n</think>\n\n", "tool_calls": [
-        {"type": "function", "function": {"name": "run", "arguments": {"cmd": "make"}}}
-    ]},
-    {"role": "tool", "content": "Error: missing header"},
-    {"role": "assistant", "content": "<think>\nadd the include\n</think>\n\nAdding it now.", "tool_calls": [
-        {"type": "function", "function": {"name": "edit", "arguments": {"file": "main.c"}}}
-    ]},
-    {"role": "tool", "content": "ok"},
-    {"role": "assistant", "content": "<think>\nverify\n</think>\n\nBuild fixed."},
-    {"role": "user", "content": "Thanks"},
-]
-
-# 92. Prefix KV cache stability across a full agentic session (default settings)
-execute_prefix_test(
-    "92. Prefix KV cache stability across a full agentic session (default settings)",
-    messages=agentic_session
-)
-
-# 93. Prefix KV cache stability with tools and xhigh reasoning
-execute_prefix_test(
-    "93. Prefix KV cache stability with tools and xhigh reasoning",
-    messages=agentic_session,
-    kwargs={"tools": tools_sample, "reasoning_effort": "xhigh"}
-)
-
-# 94. chat_template_oneline.txt renders identically to chat_template.jinja
-execute_parity_test(
-    "94. chat_template_oneline.txt renders identically to chat_template.jinja",
-    cases=[
-        ("plain", [{"role": "user", "content": "Hello"}], {}),
-        ("system + tools", [
-            {"role": "system", "content": "You are helpful."},
-            {"role": "user", "content": "Weather?"}
-        ], {"tools": tools_sample}),
-        ("agentic session", agentic_session, {}),
-        ("json format", [
-            {"role": "user", "content": "Call"},
-            {"role": "assistant", "content": "", "tool_calls": [
-                {"type": "function", "function": {"name": "f", "arguments": {"a": "1"}}}
-            ]}
-        ], {"tool_call_format": "json"}),
-    ]
-)
-
-# ==========================================
-# 13. Success Envelopes & Input Shapes (v22.3)
-# ==========================================
-
-# 95. JSON success envelope with error:null does not trigger a warning
-execute_test(
-    "95. JSON success envelope with error:null does not trigger a warning",
-    messages=[
-        {"role": "user", "content": "Query"},
-        {"role": "assistant", "content": "", "tool_calls": [{"type": "function", "function": {"name": "api", "arguments": {}}}]},
-        {"role": "tool", "content": '{"error": null, "data": {"rows": [1, 2, 3]}}\n' + "x" * 700}
-    ],
-    expected_not_in=[
-        "⚠️ SYSTEM WARNING"
-    ]
-)
-
-# 96. JSON success envelope with error:false does not trigger a warning
-execute_test(
-    "96. JSON success envelope with error:false does not trigger a warning",
-    messages=[
-        {"role": "user", "content": "Query"},
-        {"role": "assistant", "content": "", "tool_calls": [{"type": "function", "function": {"name": "api", "arguments": {}}}]},
-        {"role": "tool", "content": '{"error": false, "result": "done"}'}
-    ],
-    expected_not_in=[
-        "⚠️ SYSTEM WARNING"
-    ]
-)
-
-# 97. Inline effort tag overrides the reasoning_effort kwarg
-execute_test(
-    "97. Inline effort tag overrides the reasoning_effort kwarg",
-    messages=[{"role": "user", "content": "Answer fast <|think_low|>"}],
-    kwargs={"reasoning_effort": "xhigh"},
-    expected_in=[
-        "Reasoning effort is set to low."
-    ],
-    expected_not_in=[
-        "Reasoning effort is set to xhigh."
-    ]
-)
-
-# 98. Tool result with multipart text content is flattened
-execute_test(
-    "98. Tool result with multipart text content is flattened",
-    messages=[
-        {"role": "user", "content": "Query"},
-        {"role": "assistant", "content": "", "tool_calls": [{"type": "function", "function": {"name": "api", "arguments": {}}}]},
-        {"role": "tool", "content": [{"type": "text", "text": "RESULT_42"}]}
-    ],
-    expected_in=[
-        "<tool_response>\nRESULT_42\n</tool_response>"
-    ]
-)
-
-# 99. Argument exactly at max_tool_arg_chars is not truncated
-execute_test(
-    "99. Argument exactly at max_tool_arg_chars is not truncated",
-    messages=[
-        {"role": "user", "content": "Query"},
-        {"role": "assistant", "content": "", "tool_calls": [
-            {"type": "function", "function": {"name": "f", "arguments": {"k": "A" * 40}}}]}
-    ],
-    kwargs={"max_tool_arg_chars": 40},
-    expected_in=[
-        "A" * 40
-    ],
-    expected_not_in=[
-        "[TRUNCATED"
-    ]
-)
-
-# 100. Multiple images in a single message get sequential vision ids
-execute_test(
-    "100. Multiple images in a single message get sequential vision ids",
-    messages=[{"role": "user", "content": [
-        {"type": "image", "image": "a"},
-        {"type": "image", "image": "b"},
-        {"type": "text", "text": "compare these"}
-    ]}],
-    kwargs={"add_vision_id": True},
-    expected_in=[
-        "Picture 1: <|vision_start|><|image_pad|><|vision_end|>",
-        "Picture 2: <|vision_start|><|image_pad|><|vision_end|>"
-    ]
-)
-
-# ==========================================
-# 14. Property-Based Fuzzing (v22.3)
-# ==========================================
-
-def run_fuzz_property_test(name, cases, seed):
-    print(f"\n--- Running Test: {name} ---")
-    sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-    try:
-        import fuzz_template
-        failures = fuzz_template.run_fuzz(cases=cases, seed=seed,
-                                          template_dir=TEMPLATE_DIR,
-                                          template_file=TEMPLATE_FILE)
-    except Exception:
-        print(f"❌ FAILED with exception:\n{traceback.format_exc()}")
-        return False
-    if failures:
-        first = failures[0]
-        print(f"❌ FAILED: {len(failures)} invariant violation(s); "
-              f"first: [{first['invariant']}] {first['detail']}")
-        print(f"Repro (seed {seed}, case {first['case']}): {first['repro'][:600]}")
-        return False
-    print(f"✅ PASSED ({cases} generated conversations, seed {seed})")
-    return True
-
-def execute_fuzz_property_test(*args, **kwargs):
-    global tests_passed, tests_total
-    tests_total += 1
-    if run_fuzz_property_test(*args, **kwargs):
-        tests_passed += 1
-
-# 101. Property fuzz: generated conversations uphold all structural invariants
-execute_fuzz_property_test(
-    "101. Property fuzz: generated conversations uphold all structural invariants",
-    cases=300,
-    seed=20260820
-)
-
-print("\n==========================================")
-print(f"Results: {tests_passed} / {tests_total} tests passed ({tests_passed/tests_total*100:.1f}%)")
-print("==========================================")
-
-if tests_passed != tests_total:
-    sys.exit(1)