use std::ops::Range;
pub const EFFORT_LEVELS: &[&str] = &["minimal", "low", "medium", "high", "xhigh", "max"];
pub const DEFAULT_EFFORT_LEVELS: &[&str] = &["low", "medium", "high"];
pub const BUDGETED_EFFORT_LEVELS: &[&str] = &["minimal", "low", "medium", "high"];
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
pub struct Thinking {
pub values: Vec<serde_json::Value>,
pub default: serde_json::Value,
}
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct ThinkingControls {
pub thinks: bool,
pub enable_thinking: bool,
pub efforts: Vec<&'static str>,
pub default_on: bool,
pub default_effort: Option<&'static str>,
}
impl ThinkingControls {
pub fn choices(&self) -> Vec<&'static str> {
if !self.thinks {
return Vec::new();
}
let mut choices = vec!["none"];
if !self.efforts.is_empty() {
choices.extend(&self.efforts);
} else if self.enable_thinking {
choices.push("thinking");
}
choices
}
pub fn thinks_without_levels(&self) -> bool {
self.thinks && self.efforts.is_empty()
}
pub fn thinking(&self, budgeted: bool) -> Option<Thinking> {
if !self.thinks {
return None;
}
let levels: &[&str] = match (self.efforts.is_empty(), self.enable_thinking && budgeted) {
(false, _) => &self.efforts,
(true, true) => BUDGETED_EFFORT_LEVELS,
(true, false) => &[],
};
let mut values = vec![false.into()];
values.extend(levels.iter().map(|level| (*level).into()));
let default = match levels {
[] => {
values.push(true.into());
self.default_on.into()
}
_ if !self.default_on => false.into(),
_ => self
.default_effort
.filter(|level| levels.contains(level))
.unwrap_or(if levels.contains(&"medium") {
"medium"
} else {
levels[levels.len() - 1]
})
.into(),
};
Some(Thinking { values, default })
}
}
pub fn thinking_controls(template: &str) -> ThinkingControls {
let template = strip_comments(template);
let lower = template.to_ascii_lowercase();
let thinks = lower.contains("think") || lower.contains("reasoning");
if !thinks {
return ThinkingControls::default();
}
let enable_thinking = template.contains("enable_thinking");
let efforts = if template.contains("reasoning_effort") {
let effort_blocks: Vec<&str> = blocks(&template)
.filter(|block| block.contains("reasoning_effort"))
.collect();
let levels_among = |literals: Vec<&str>| -> Vec<&'static str> {
EFFORT_LEVELS
.iter()
.copied()
.filter(|level| literals.contains(level))
.collect()
};
let (mut accepted, mut named) = (Vec::new(), Vec::new());
for block in effort_blocks {
let mut from = 0;
for (list, of_effort) in membership_lists(block) {
if of_effort {
accepted.extend(quoted_literals(&block[list]));
} else if list.start >= from {
named.extend(quoted_literals(&block[from..list.start]));
from = list.end;
}
}
named.extend(quoted_literals(&block[from..]));
}
let (accepted, named) = (levels_among(accepted), levels_among(named));
if accepted.len() >= 2 {
accepted
} else if named.len() >= 2 {
named
} else {
DEFAULT_EFFORT_LEVELS.to_vec()
}
} else {
Vec::new()
};
let squeezed: String = lower.split_whitespace().collect();
let default_on = !enable_thinking
|| [
"enable_thinkingisfalse",
"enable_thinking==false",
"notenable_thinking",
"enable_thinkingisundefinedor",
"enable_thinkingisnotdefinedor",
"enable_thinking|default(true)",
]
.iter()
.any(|test| squeezed.contains(test));
let default_effort = squeezed
.split_once("reasoning_effort|default(")
.and_then(|(_, rest)| {
rest.starts_with(['\'', '"']).then_some(())?;
let literal = quoted_literals(rest).next()?;
EFFORT_LEVELS
.iter()
.copied()
.find(|level| *level == literal)
});
ThinkingControls {
thinks,
enable_thinking,
efforts,
default_on,
default_effort,
}
}
pub fn handles_tools(template: &str) -> bool {
blocks(&strip_comments(template)).any(|block| names_variable(block, "tools"))
}
fn names_variable(block: &str, name: &str) -> bool {
let bytes = block.as_bytes();
let is_word = |b: u8| b.is_ascii_alphanumeric() || b == b'_';
let (mut at, mut previous) = (0, None::<u8>);
while at < bytes.len() {
let c = bytes[at];
if c == b'\'' || c == b'"' {
at += 1;
while at < bytes.len() && bytes[at] != c {
at += if bytes[at] == b'\\' { 2 } else { 1 };
}
at += 1;
previous = Some(c);
} else if is_word(c) {
let end = bytes[at..]
.iter()
.position(|b| !is_word(*b))
.map_or(bytes.len(), |n| at + n);
if &block[at..end] == name && previous != Some(b'.') {
return true;
}
at = end;
previous = Some(b'a');
} else {
if !c.is_ascii_whitespace() {
previous = Some(c);
}
at += 1;
}
}
false
}
fn strip_comments(template: &str) -> String {
let mut out = String::with_capacity(template.len());
let mut rest = template;
while let Some(start) = rest.find("{#") {
out.push_str(&rest[..start]);
match rest[start..].find("#}") {
Some(end) => rest = &rest[start + end + 2..],
None => return out,
}
}
out.push_str(rest);
out
}
fn blocks(template: &str) -> impl Iterator<Item = &str> {
let mut rest = template;
std::iter::from_fn(move || {
let start = rest.find("{%").into_iter().chain(rest.find("{{")).min()?;
let close = if rest[start..].starts_with("{%") {
"%}"
} else {
"}}"
};
let end = rest[start + 2..].find(close)?;
let block = &rest[start + 2..start + 2 + end];
rest = &rest[start + 2 + end + 2..];
Some(block)
})
}
fn membership_lists(block: &str) -> impl Iterator<Item = (Range<usize>, bool)> + '_ {
block.match_indices("in").filter_map(|(at, _)| {
let before = block[..at].chars().next_back()?;
if !(before.is_whitespace() || before == ')') {
return None;
}
let after = &block[at + 2..];
let open = at + 2 + (after.len() - after.trim_start().len());
let close = match block[open..].chars().next()? {
'(' => ')',
'[' => ']',
_ => return None,
};
let end = open + block[open..].find(close)?;
let lhs = block[..at].trim_end();
let lhs = lhs.strip_suffix("not").map_or(lhs, str::trim_end);
Some((
open + 1..end,
left_operand(lhs).contains("reasoning_effort"),
))
})
}
fn left_operand(before: &str) -> &str {
let bytes = before.as_bytes();
let (mut start, mut depth) = (bytes.len(), 0usize);
while start > 0 {
let c = bytes[start - 1];
match c {
b')' | b']' => depth += 1,
b'(' | b'[' if depth > 0 => depth -= 1,
_ if depth > 0 => {}
_ if c.is_ascii_whitespace() => {
let pipe_after = before[start..].trim_start().starts_with('|');
let pipe_before = before[..start - 1].trim_end().ends_with('|');
if !(pipe_after || pipe_before) {
break;
}
}
_ if c.is_ascii_alphanumeric() || b"_.|".contains(&c) => {}
_ => break,
}
start -= 1;
}
&before[start..]
}
fn quoted_literals(text: &str) -> impl Iterator<Item = &str> {
let mut rest = text;
std::iter::from_fn(move || {
let start = rest.find(['\'', '"'])?;
let quote = rest.as_bytes()[start] as char;
let after = &rest[start + 1..];
let end = after.find(quote)?;
rest = &after[end + 1..];
Some(&after[..end])
})
}
#[cfg(test)]
mod tests {
use super::*;
const QWEN3_8: &str = r#"
{%- if enable_thinking is undefined or enable_thinking is true %}
{%- set resolved_reasoning_effort = reasoning_effort|default('xhigh') %}
{%- if resolved_reasoning_effort == 'high' %}
{%- set resolved_reasoning_effort = 'xhigh' %}
{%- endif %}
{%- if resolved_reasoning_effort not in ('xhigh', 'medium', 'low') %}
{{- raise_exception('Unexpected reasoning effort ' ~ reasoning_effort ~ '. Supported types are xhigh (default), medium, and low.') }}
{%- endif %}
{%- endif %}
{%- if enable_thinking is defined and enable_thinking is false %}
{{- '<think>\n\n</think>\n\n' }}
{%- endif %}
"#;
#[test]
fn qwen3_8_names_its_levels_and_its_switch() {
let controls = thinking_controls(QWEN3_8);
assert_eq!(
controls,
ThinkingControls {
thinks: true,
enable_thinking: true,
efforts: vec!["low", "medium", "xhigh"],
default_on: true,
default_effort: Some("xhigh"),
}
);
assert_eq!(controls.choices(), ["none", "low", "medium", "xhigh"]);
assert!(!controls.thinks_without_levels());
let one_line = QWEN3_8.replace('\n', "");
assert_eq!(thinking_controls(&one_line), controls);
let upstream = QWEN3_8.replace(
"{%- if resolved_reasoning_effort == 'high' %}\n {%- set resolved_reasoning_effort = 'xhigh' %}\n {%- endif %}",
"",
);
assert!(!upstream.contains("'high'"));
assert_eq!(thinking_controls(&upstream), controls);
}
#[test]
fn a_membership_test_narrows_the_named_levels() {
let t = "{%- if reasoning_effort == 'max' %}{% set reasoning_effort = 'high' %}{% endif %}\
{%- if reasoning_effort not in ['high', \"low\"] %}{{ raise_exception('bad') }}{% endif %}";
assert_eq!(thinking_controls(t).efforts, vec!["low", "high"]);
let one = "{%- if reasoning_effort in ('low',) or reasoning_effort == 'high' %}{% endif %}";
assert_eq!(thinking_controls(one).efforts, vec!["low", "high"]);
let join = "{{- reasoning_effort ~ join('low', 'high') ~ min('medium', 'max') }}";
assert_eq!(
thinking_controls(join).efforts,
vec!["low", "medium", "high", "max"]
);
let other = "{%- if mode in ('low', 'high') and reasoning_effort in ('medium', 'max') %}";
assert_eq!(thinking_controls(other).efforts, vec!["medium", "max"]);
let bare = "{%- if mode in ('low', 'high') and reasoning_effort %}";
assert_eq!(thinking_controls(bare).efforts, DEFAULT_EFFORT_LEVELS);
let block = "reasoning_effort not in ('a', 'b') and y in ('c', 'd') \
or (reasoning_effort|lower) in[1] or reasoning_effort | lower in [2] \
or ( reasoning_effort | default('x') ) in (3) or reasoning_effort in (";
assert_eq!(
membership_lists(block)
.map(|(list, of_effort)| (&block[list], of_effort))
.collect::<Vec<_>>(),
[
("'a', 'b'", true),
("'c', 'd'", false),
("1", true),
("2", true),
("3", true)
]
);
}
#[test]
fn a_template_that_names_no_choices_gets_the_default_levels() {
let gpt_oss = r#"
{%- if reasoning_effort is not defined %}{%- set reasoning_effort = "medium" %}{%- endif %}
{{- "Reasoning: " + reasoning_effort + "\n\n" }}
"#;
assert_eq!(
thinking_controls(gpt_oss).efforts,
DEFAULT_EFFORT_LEVELS.to_vec()
);
assert!(!thinking_controls(gpt_oss).thinks_without_levels());
}
#[test]
fn a_switch_alone_offers_off_and_on() {
let gemma4 = "{%- set enable_thinking = enable_thinking | default(false) -%}\
{%- if enable_thinking -%}<|think|>{%- endif -%}";
let controls = thinking_controls(gemma4);
assert!(controls.enable_thinking && controls.efforts.is_empty());
assert_eq!(controls.choices(), ["none", "thinking"]);
assert!(controls.thinks_without_levels());
}
#[test]
fn thinking_reports_the_values_a_template_takes() {
use serde_json::json;
let thinking = |template: &str, budgeted| {
let t = thinking_controls(template).thinking(budgeted)?;
Some((json!(t.values), t.default))
};
assert_eq!(
thinking(QWEN3_8, false),
Some((json!([false, "low", "medium", "xhigh"]), json!("xhigh")))
);
let gpt_oss = r#"{{- "Reasoning: " + reasoning_effort | default("medium") }}"#;
assert_eq!(
thinking(gpt_oss, true),
Some((json!([false, "low", "medium", "high"]), json!("medium")))
);
let qwen3_5 = "{%- if enable_thinking is defined and enable_thinking is false %}<think></think>{%- endif %}";
let undefined =
"{%- if enable_thinking is not defined or enable_thinking %}<think>{%- endif %}";
assert_eq!(
thinking(undefined, false),
Some((json!([false, true]), json!(true)))
);
let gemma4 = "{%- set enable_thinking = enable_thinking | default(false) -%}{%- if enable_thinking -%}<|think|>{%- endif -%}";
assert_eq!(
thinking(qwen3_5, false),
Some((json!([false, true]), json!(true)))
);
assert_eq!(
thinking(gemma4, false),
Some((json!([false, true]), json!(false)))
);
assert_eq!(
thinking(qwen3_5, true),
Some((
json!([false, "minimal", "low", "medium", "high"]),
json!("medium")
))
);
assert_eq!(
thinking(gemma4, true),
Some((
json!([false, "minimal", "low", "medium", "high"]),
json!(false)
))
);
let kimi =
"{%- if thinking is defined and thinking is false -%}<think></think>{%- endif -%}";
assert_eq!(
thinking(kimi, true),
Some((json!([false, true]), json!(true)))
);
assert_eq!(thinking("{{ messages }}", true), None);
}
#[test]
fn thinking_without_a_kwarg_offers_only_off() {
let kimi =
"{%- if thinking is defined and thinking is false -%}<think></think>{%- endif -%}";
assert_eq!(thinking_controls(kimi).choices(), ["none"]);
let minimax = "{%- set reasoning_content = content.split('</think>')[0] -%}";
assert_eq!(thinking_controls(minimax).choices(), ["none"]);
}
#[test]
fn a_plain_template_has_no_controls() {
let llama = "{# no thinking here #}{{- '<|start_header_id|>' + message['role'] }}";
assert_eq!(thinking_controls(llama), ThinkingControls::default());
assert!(thinking_controls(llama).choices().is_empty());
assert!(!thinking_controls(llama).thinks_without_levels());
assert_eq!(thinking_controls(""), ThinkingControls::default());
}
#[test]
fn levels_are_ordered_deduplicated_and_scoped_to_the_variables_blocks() {
let t = r#"{%- if reasoning_effort == "max" or reasoning_effort == "low" or reasoning_effort == "none" %}
{%- if reasoning_effort == 'low' %}{%- set unrelated = 'high' %}"#;
assert_eq!(thinking_controls(t).efforts, vec!["low", "max"]);
}
#[test]
fn a_template_that_reads_tools_handles_them() {
let qwen = r##"{%- if tools %}{{- '<|im_start|>system\n' }}{{- "# Tools\n\n<tools>" }}
{%- for tool in tools %}{{- "\n" }}{{- tool | tojson }}{%- endfor %}{%- endif %}"##;
let llama = "{%- if not tools is defined %}{%- set tools = none %}{%- endif %}";
let gpt_oss = "{{- tools | tojson(indent=2) -}}";
let macro_ = "{%- macro render_tools(tools) -%}{{ tools|length }}{%- endmacro -%}";
let one_line = "{%-if tools%}x{%-endif%}";
for template in [qwen, llama, gpt_oss, macro_, one_line] {
assert!(handles_tools(template), "{template}");
}
assert!(handles_tools(r"{{ 'it\'s' ~ tools }}"));
}
#[test]
fn a_template_that_never_reads_tools_does_not() {
let gemma3 = "{{ bos_token }}{%- for message in messages -%}\
{{ '<start_of_turn>' + message['role'] + '\\n' }}{%- endfor -%}";
assert!(!handles_tools(gemma3));
for template in [
"{%- if tool_calls %}{{ custom_tools }}{{ tools_in_user_message }}{%- endif %}",
"{%- for tool in message.tool_calls %}{%- endfor %}",
"{{ message.tools }}",
"{{ message['tools'] }}",
"{{ messages | map(attribute='tools') }}",
r#"{{- "You may use tools." }}"#,
"{# tools #}{{ x }}",
"You may use tools. {{ x }}",
"",
] {
assert!(!handles_tools(template), "{template}");
}
}
#[test]
fn blocks_and_literals_are_walked_in_order() {
assert_eq!(
blocks("a {% if x %}b{{ y }}c {% end").collect::<Vec<_>>(),
[" if x ", " y "]
);
assert_eq!(
quoted_literals(r#"x in ('a', "b c") ~ 'd"#).collect::<Vec<_>>(),
["a", "b c"]
);
assert_eq!(strip_comments("a{# b #}c{# open"), "ac");
}
}