Commit b8f96c3e8 for llama.cpp
commit b8f96c3e82284028cb077811ed1666caac3c5bac
Author: e-mon <emon18@icloud.com>
Date: Thu Oct 1 14:33:55 2026 +0900
common : add LLM-jp-4.1 Harmony dialect handler (#29681)
LLM-jp-4.1 uses the GPT-OSS format, but its tokenizer decodes a space
after every special token and parallel tool calls are separated by
<|end|>. The GPT-OSS handler rejects this output, so add a dedicated
handler, selected by the chat_format=llm-jp-harmony-v1 declaration in
the chat template.
Assisted-by: Claude Fable 5.1
diff --git a/common/chat.cpp b/common/chat.cpp
index ed1942e15..3502b96eb 100644
--- a/common/chat.cpp
+++ b/common/chat.cpp
@@ -1099,6 +1099,12 @@ std::optional<common_chat_params> common_chat_try_specialized_template(
return common_chat_params_init_ministral_3(tmpl, params);
}
+ // LLM-jp-4.1 - GPT-OSS dialect (spaces after special tokens, <|end|>-separated parallel calls)
+ if (src.find("chat_format=llm-jp-harmony-v1") != std::string::npos) {
+ LOG_DBG("Using specialized template: LLM-jp Harmony v1\n");
+ return common_chat_params_init_llm_jp_harmony(tmpl, params);
+ }
+
// GPT-OSS - has unique channel-based structure that needs dedicated handler
if (src.find("<|channel|>") != std::string::npos) {
LOG_DBG("Using specialized template: GPT-OSS\n");
diff --git a/common/parsers/llm-jp-harmony.cpp b/common/parsers/llm-jp-harmony.cpp
new file mode 100644
index 000000000..b012f9a05
--- /dev/null
+++ b/common/parsers/llm-jp-harmony.cpp
@@ -0,0 +1,164 @@
+#include "parsers.h"
+
+// LLM-jp-4.1: the GPT-OSS (Harmony) format with two differences
+// - the tokenizer emits a space after every special token: "<|channel|> analysis<|message|> ..."
+// - parallel tool calls are consecutive assistant messages, all but the last closed by <|end|>
+common_chat_params common_chat_params_init_llm_jp_harmony(const common_chat_template & tmpl,
+ const autoparser::generation_params & inputs) {
+ common_chat_params data;
+
+ // Copy reasoning to the "thinking" field as expected by the template
+ auto adjusted_messages = json::array();
+ for (auto msg : inputs.messages) {
+ if (msg.contains("reasoning_content") && msg.at("reasoning_content").is_string()) {
+ msg["thinking"] = msg.at("reasoning_content");
+ if (msg.contains("tool_calls") && msg.at("tool_calls").is_array() && !msg.at("tool_calls").empty()) {
+ msg.erase("content");
+ }
+ }
+ adjusted_messages.push_back(msg);
+ }
+
+ auto prompt = common_chat_template_direct_apply_impl(tmpl, inputs, /* messages_override= */ adjusted_messages);
+
+ // Check if we need to replace the return token with end token during
+ // inference and without generation prompt. For more details see:
+ // https://github.com/ggml-org/llama.cpp/issues/15417
+ if (inputs.is_inference && !inputs.add_generation_prompt) {
+ static constexpr std::string_view return_token = "<|return|>";
+ static constexpr std::string_view end_token = "<|end|>";
+ if (size_t pos = prompt.rfind(return_token); pos != std::string::npos) {
+ prompt.replace(pos, return_token.length(), end_token);
+ }
+ }
+
+ data.prompt = prompt;
+ data.generation_prompt = common_chat_template_generation_prompt_impl(tmpl, inputs, /* messages_override= */ adjusted_messages);
+ data.message_delimiters = {
+ { COMMON_CHAT_ROLE_ASSISTANT, "<|start|>assistant" },
+ { COMMON_CHAT_ROLE_USER, "<|start|>user" },
+ { COMMON_CHAT_ROLE_SYSTEM, "<|start|>developer" },
+ { COMMON_CHAT_ROLE_SYSTEM, "<|start|>system" },
+ { COMMON_CHAT_ROLE_TOOL, "<|start|>functions" },
+ };
+
+ data.format = COMMON_CHAT_FORMAT_PEG_NATIVE;
+ data.supports_thinking = true;
+
+ data.thinking_start_tag = "<|channel|>analysis<|message|>";
+ data.thinking_end_tags = {"<|end|>"};
+
+ // These special tokens are required to parse properly, so we include them
+ // even if parse_tool_calls is false.
+ data.preserved_tokens = {
+ "<|channel|>", "<|constrain|>", "<|message|>", "<|start|>", "<|end|>",
+ };
+
+ // Adjust prompt for continuation
+ if (inputs.has_continuation()) {
+ const auto & msg = inputs.continue_msg;
+
+ data.generation_prompt = "<|start|>assistant<|channel|>analysis<|message|>" + msg.reasoning_content;
+ if (inputs.continue_final_message == COMMON_CHAT_CONTINUATION_CONTENT) {
+ data.generation_prompt += "<|end|><|start|>assistant<|channel|>final<|message|>" + msg.render_content();
+ }
+
+ data.prompt += data.generation_prompt;
+ }
+
+ auto has_tools = inputs.tools.is_array() && !inputs.tools.empty();
+ auto has_response_format = !inputs.json_schema.is_null() && inputs.json_schema.is_object();
+ auto include_grammar = has_response_format || (has_tools && inputs.tool_choice != COMMON_CHAT_TOOL_CHOICE_NONE);
+ auto extract_reasoning = inputs.reasoning_format != COMMON_REASONING_FORMAT_NONE;
+
+ auto parser = build_chat_peg_parser([&](common_chat_peg_builder & p) {
+ // tokenizer space after special tokens; not p.space() since GBNF `space` allows one space only
+ auto sp = p.chars("[ ]", 0, -1);
+ auto channel_tag = p.literal("<|channel|>") + sp;
+ // one space only: keep an intentional leading space in the body
+ auto message = p.literal("<|message|>") + p.optional(p.literal(" "));
+
+ auto start = p.rule("start", p.literal("<|start|>") + sp + p.literal("assistant"));
+ auto end = p.rule("end", p.literal("<|end|>"));
+ auto content = p.rule("message-content", p.until("<|end|>"));
+ auto channel = channel_tag + (p.literal("commentary") | p.literal("analysis"));
+ auto constrain_type = p.chars("[A-Za-z0-9_-]", 1, -1);
+ auto constraint = p.optional(p.space() + p.optional(p.literal("<|constrain|>") + sp) + constrain_type);
+
+ auto start_analysis = channel_tag + p.literal("analysis") + message;
+ if (extract_reasoning) {
+ p.rule("analysis", start_analysis + p.reasoning(content) + end);
+ } else {
+ p.rule("analysis", p.content(start_analysis + content + end));
+ }
+
+ auto analysis = p.ref("analysis");
+ auto preamble = p.rule("preamble", channel_tag + p.literal("commentary") + message + p.content(content) + end);
+ auto final_msg = p.rule("final", channel_tag + p.literal("final") + message + p.content(content));
+
+ auto any = p.rule("any", preamble | analysis);
+
+ if (has_response_format) {
+ auto response_format = p.rule("response-format",
+ channel_tag + p.literal("final") + constraint + message +
+ p.content(p.schema(p.json(), "response-format-schema", inputs.json_schema)));
+
+ return p.zero_or_more(start + analysis) + start + response_format;
+ }
+
+ if (has_tools && inputs.tool_choice != COMMON_CHAT_TOOL_CHOICE_NONE) {
+ auto tool_choice = p.choice();
+
+ foreach_function(inputs.tools, [&](const json & tool) {
+ const auto & function = tool.at("function");
+ std::string name = function.at("name");
+ const auto params = common_chat_tool_parameters(function);
+
+ auto func_name = p.literal(" to=functions.") + p.tool_name(p.literal(name));
+ auto args = p.tool_args(p.schema(p.json(), "tool-" + name + "-schema", params));
+
+ // recipient in role header
+ // <|start|>assistant to=functions.NAME<|channel|>(commentary|analysis)[constraint]<|message|>ARGS
+ auto tool_in_role = p.tool(p.tool_open(func_name + channel + constraint + message) + args);
+
+ // recipient in channel header
+ // <|channel|>(commentary|analysis) to=functions.NAME[constraint]<|message|>ARGS
+ auto tool_in_channel = p.tool(p.tool_open(channel + func_name + constraint + message) + args);
+
+ tool_choice |= p.rule("tool-" + name, tool_in_role | tool_in_channel);
+ });
+
+ // parallel calls are separated by <|end|>; inside the trigger rule so the lazy grammar covers all of them
+ auto tool_calls = inputs.parallel_tool_calls
+ ? tool_choice + p.zero_or_more(end + start + tool_choice)
+ : tool_choice;
+ auto tool_call = p.trigger_rule("tool-call", tool_calls);
+
+ if (inputs.tool_choice == COMMON_CHAT_TOOL_CHOICE_REQUIRED) {
+ return p.zero_or_more(start + any) + start + tool_call;
+ }
+
+ return p.zero_or_more(start + any) + start + (tool_call | final_msg);
+ }
+
+ return p.zero_or_more(start + any) + start + final_msg;
+ });
+
+ data.parser = parser.save();
+
+ if (include_grammar) {
+ data.grammar_lazy = !(has_response_format || (has_tools && inputs.tool_choice == COMMON_CHAT_TOOL_CHOICE_REQUIRED));
+ data.grammar = build_grammar([&](const common_grammar_builder & builder) {
+ parser.build_grammar(builder, data.grammar_lazy);
+ });
+
+ data.grammar_triggers = {
+ { COMMON_GRAMMAR_TRIGGER_TYPE_PATTERN, "^\\s+to$" },
+ { COMMON_GRAMMAR_TRIGGER_TYPE_PATTERN, "^<\\|channel\\|>\\s*(?:commentary|analysis)\\s+to=functions$" },
+ { COMMON_GRAMMAR_TRIGGER_TYPE_PATTERN, "<\\|start\\|>\\s*assistant(\\s+to)" },
+ { COMMON_GRAMMAR_TRIGGER_TYPE_PATTERN, "<\\|start\\|>\\s*assistant(<\\|channel\\|>\\s*(?:commentary|analysis)\\s+to)" }
+ };
+ }
+
+ return data;
+}
diff --git a/common/parsers/parsers.h b/common/parsers/parsers.h
index f86636007..0caf62d8c 100644
--- a/common/parsers/parsers.h
+++ b/common/parsers/parsers.h
@@ -68,6 +68,8 @@ common_chat_params common_chat_params_init_ling3(const common_chat_template & tm
// tool_list_tokens preserves the LFM2 system tool-list markers; LFM2.5 renders without them
common_chat_params common_chat_params_init_lfm2(const common_chat_template & tmpl, const autoparser::generation_params & inputs, bool tool_list_tokens);
+common_chat_params common_chat_params_init_llm_jp_harmony(const common_chat_template & tmpl, const autoparser::generation_params & inputs);
+
common_chat_params common_chat_params_init_minicpm5(const common_chat_template & tmpl, const autoparser::generation_params & inputs);
common_chat_params common_chat_params_init_minimax_m3(const common_chat_template & tmpl, const autoparser::generation_params & inputs);
diff --git a/common/parsers/sources.cmake b/common/parsers/sources.cmake
index 70af84e25..5815939d6 100644
--- a/common/parsers/sources.cmake
+++ b/common/parsers/sources.cmake
@@ -13,6 +13,7 @@ set(LLAMA_CHAT_PARSERS_SOURCES
${CMAKE_CURRENT_LIST_DIR}/kimi-k3.cpp
${CMAKE_CURRENT_LIST_DIR}/ling3.cpp
${CMAKE_CURRENT_LIST_DIR}/lfm2.cpp
+ ${CMAKE_CURRENT_LIST_DIR}/llm-jp-harmony.cpp
${CMAKE_CURRENT_LIST_DIR}/minicpm5.cpp
${CMAKE_CURRENT_LIST_DIR}/minimax-m3.cpp
${CMAKE_CURRENT_LIST_DIR}/ministral3.cpp
diff --git a/docs/autoparser.md b/docs/autoparser.md
index 2a7ea00b4..0f8b70171 100644
--- a/docs/autoparser.md
+++ b/docs/autoparser.md
@@ -509,6 +509,7 @@ The following templates have active tests in `tests/test-chat.cpp`:
| Kimi-K2 / Kimi-K2-Instruct | JSON_NATIVE | JSON tools with special markers |
| Llama 3.1/3.2/3.3 | JSON_NATIVE | Standard Llama tool format |
| OpenAI GPT-OSS | Specialized | Channel-based (dedicated handler) |
+| LLM-jp-4.1 | Specialized | GPT-OSS dialect (dedicated handler) |
| Apriel 1.5 | JSON_NATIVE | `<tool_calls>` wrapper with JSON array |
| Apriel 1.6 Thinker | Reasoning | Implicit reasoning start |
| Mistral Small 3.2 | JSON_NATIVE | `[TOOL_CALLS]func[ARGS]{...}` with call ID |
diff --git a/docs/function-calling.md b/docs/function-calling.md
index 850b59ce7..28eecbe25 100644
--- a/docs/function-calling.md
+++ b/docs/function-calling.md
@@ -16,6 +16,7 @@ Function calling is supported for all models (see https://github.com/ggml-org/ll
- Firefunction v2
- Command R7B
- DeepSeek R1 (WIP / seems reluctant to call any tools?)
+ - GPT-OSS (Harmony), LLM-jp-4.1 (Harmony dialect)
- Generic tool call is supported when the template isn't recognized by native format handlers (you'll see `Chat format: Generic` in the logs).
- Use `--chat-template-file` to override the template when appropriate (see examples below)
diff --git a/models/templates/llm-jp-llm-jp-4.1-8b-thinking.jinja b/models/templates/llm-jp-llm-jp-4.1-8b-thinking.jinja
new file mode 100644
index 000000000..ccf4ddf1c
--- /dev/null
+++ b/models/templates/llm-jp-llm-jp-4.1-8b-thinking.jinja
@@ -0,0 +1,352 @@
+{#- chat_format=llm-jp-harmony-v1 -#}
+{#-
+ In addition to the normal inputs of `messages` and `tools`, this template also accepts the
+ following kwargs:
+ - "builtin_tools": A list, can contain "browser" and/or "python".
+ - "model_identity": A string that optionally describes the model identity.
+ - "reasoning_effort": A string that describes the reasoning effort, defaults to "medium".
+ #}
+
+{#- Tool Definition Rendering ============================================== #}
+{%- macro render_typescript_type(param_spec, required_params, is_nullable=false) -%}
+ {%- if param_spec.type == "array" -%}
+ {%- if param_spec['items'] -%}
+ {%- if param_spec['items']['type'] == "string" -%}
+ {{- "string[]" }}
+ {%- elif param_spec['items']['type'] == "number" -%}
+ {{- "number[]" }}
+ {%- elif param_spec['items']['type'] == "integer" -%}
+ {{- "number[]" }}
+ {%- elif param_spec['items']['type'] == "boolean" -%}
+ {{- "boolean[]" }}
+ {%- else -%}
+ {%- set inner_type = render_typescript_type(param_spec['items'], required_params) -%}
+ {%- if inner_type == "object | object" or inner_type|length > 50 -%}
+ {{- "any[]" }}
+ {%- else -%}
+ {{- inner_type + "[]" }}
+ {%- endif -%}
+ {%- endif -%}
+ {%- if param_spec.nullable -%}
+ {{- " | null" }}
+ {%- endif -%}
+ {%- else -%}
+ {{- "any[]" }}
+ {%- if param_spec.nullable -%}
+ {{- " | null" }}
+ {%- endif -%}
+ {%- endif -%}
+ {%- elif param_spec.type is defined and param_spec.type is iterable and param_spec.type is not string and param_spec.type is not mapping and param_spec.type[0] is defined -%}
+ {#- Handle array of types like ["object", "object"] from Union[dict, list] #}
+ {%- if param_spec.type | length > 1 -%}
+ {{- param_spec.type | join(" | ") }}
+ {%- else -%}
+ {{- param_spec.type[0] }}
+ {%- endif -%}
+ {%- elif param_spec.oneOf -%}
+ {#- Handle oneOf schemas - check for complex unions and fallback to any #}
+ {%- set has_object_variants = false -%}
+ {%- for variant in param_spec.oneOf -%}
+ {%- if variant.type == "object" -%}
+ {%- set has_object_variants = true -%}
+ {%- endif -%}
+ {%- endfor -%}
+ {%- if has_object_variants and param_spec.oneOf|length > 1 -%}
+ {{- "any" }}
+ {%- else -%}
+ {%- for variant in param_spec.oneOf -%}
+ {{- render_typescript_type(variant, required_params) -}}
+ {%- if variant.description %}
+ {{- "// " + variant.description }}
+ {%- endif -%}
+ {%- if variant.default is defined %}
+ {{ "// default: " + variant.default|tojson }}
+ {%- endif -%}
+ {%- if not loop.last %}
+ {{- " | " }}
+ {% endif -%}
+ {%- endfor -%}
+ {%- endif -%}
+ {%- elif param_spec.type == "string" -%}
+ {%- if param_spec.enum -%}
+ {{- '"' + param_spec.enum|join('" | "') + '"' -}}
+ {%- else -%}
+ {{- "string" }}
+ {%- if param_spec.nullable %}
+ {{- " | null" }}
+ {%- endif -%}
+ {%- endif -%}
+ {%- elif param_spec.type == "number" -%}
+ {{- "number" }}
+ {%- elif param_spec.type == "integer" -%}
+ {{- "number" }}
+ {%- elif param_spec.type == "boolean" -%}
+ {{- "boolean" }}
+
+ {%- elif param_spec.type == "object" -%}
+ {%- if param_spec.properties -%}
+ {{- "{\n" }}
+ {%- for prop_name, prop_spec in param_spec.properties.items() -%}
+ {{- prop_name -}}
+ {%- if prop_name not in (param_spec.required or []) -%}
+ {{- "?" }}
+ {%- endif -%}
+ {{- ": " }}
+ {{ render_typescript_type(prop_spec, param_spec.required or []) }}
+ {%- if not loop.last -%}
+ {{-", " }}
+ {%- endif -%}
+ {%- endfor -%}
+ {{- "}" }}
+ {%- else -%}
+ {{- "object" }}
+ {%- endif -%}
+ {%- else -%}
+ {{- "any" }}
+ {%- endif -%}
+{%- endmacro -%}
+
+{%- macro render_tool_namespace(namespace_name, tools) -%}
+ {{- "## " + namespace_name + "\n\n" }}
+ {{- "namespace " + namespace_name + " {\n\n" }}
+ {%- for tool in tools %}
+ {%- set tool = tool.function %}
+ {{- "// " + tool.description + "\n" }}
+ {{- "type "+ tool.name + " = " }}
+ {%- if tool.parameters and tool.parameters.properties %}
+ {{- "(_: {\n" }}
+ {%- for param_name, param_spec in tool.parameters.properties.items() %}
+ {%- if param_spec.description %}
+ {{- "// " + param_spec.description + "\n" }}
+ {%- endif %}
+ {{- param_name }}
+ {%- if param_name not in (tool.parameters.required or []) -%}
+ {{- "?" }}
+ {%- endif -%}
+ {{- ": " }}
+ {{- render_typescript_type(param_spec, tool.parameters.required or []) }}
+ {%- if param_spec.default is defined -%}
+ {%- if param_spec.enum %}
+ {{- ", // default: " + param_spec.default|tojson }}
+ {%- elif param_spec.oneOf %}
+ {{- "// default: " + param_spec.default|tojson }}
+ {%- else %}
+ {{- ", // default: " + param_spec.default|tojson }}
+ {%- endif -%}
+ {%- endif -%}
+ {%- if not loop.last %}
+ {{- ",\n" }}
+ {%- else %}
+ {{- ",\n" }}
+ {%- endif -%}
+ {%- endfor %}
+ {{- "}) => any;\n\n" }}
+ {%- else -%}
+ {{- "() => any;\n\n" }}
+ {%- endif -%}
+ {%- endfor %}
+ {{- "} // namespace " + namespace_name }}
+{%- endmacro -%}
+
+{%- macro render_builtin_tools(browser_tool, python_tool) -%}
+ {%- if browser_tool %}
+ {{- "## browser\n\n" }}
+ {{- "// Tool for browsing.\n" }}
+ {{- "// The `cursor` appears in brackets before each browsing display: `[{cursor}]`.\n" }}
+ {{- "// Cite information from the tool using the following format:\n" }}
+ {{- "// `【{cursor}†L{line_start}(-L{line_end})?】`, for example: `【6†L9-L11】` or `【8†L3】`.\n" }}
+ {{- "// Do not quote more than 10 words directly from the tool output.\n" }}
+ {{- "// sources=web (default: web)\n" }}
+ {{- "namespace browser {\n\n" }}
+ {{- "// Searches for information related to `query` and displays `topn` results.\n" }}
+ {{- "type search = (_: {\n" }}
+ {{- "query: string,\n" }}
+ {{- "topn?: number, // default: 10\n" }}
+ {{- "source?: string,\n" }}
+ {{- "}) => any;\n\n" }}
+ {{- "// Opens the link `id` from the page indicated by `cursor` starting at line number `loc`, showing `num_lines` lines.\n" }}
+ {{- "// Valid link ids are displayed with the formatting: `【{id}†.*】`.\n" }}
+ {{- "// If `cursor` is not provided, the most recent page is implied.\n" }}
+ {{- "// If `id` is a string, it is treated as a fully qualified URL associated with `source`.\n" }}
+ {{- "// If `loc` is not provided, the viewport will be positioned at the beginning of the document or centered on the most relevant passage, if available.\n" }}
+ {{- "// Use this function without `id` to scroll to a new location of an opened page.\n" }}
+ {{- "type open = (_: {\n" }}
+ {{- "id?: number | string, // default: -1\n" }}
+ {{- "cursor?: number, // default: -1\n" }}
+ {{- "loc?: number, // default: -1\n" }}
+ {{- "num_lines?: number, // default: -1\n" }}
+ {{- "view_source?: boolean, // default: false\n" }}
+ {{- "source?: string,\n" }}
+ {{- "}) => any;\n\n" }}
+ {{- "// Finds exact matches of `pattern` in the current page, or the page given by `cursor`.\n" }}
+ {{- "type find = (_: {\n" }}
+ {{- "pattern: string,\n" }}
+ {{- "cursor?: number, // default: -1\n" }}
+ {{- "}) => any;\n\n" }}
+ {{- "} // namespace browser\n\n" }}
+ {%- endif -%}
+
+ {%- if python_tool %}
+ {{- "## python\n\n" }}
+ {{- "Use this tool to execute Python code in your chain of thought. The code will not be shown to the user. This tool should be used for internal reasoning, but not for code that is intended to be visible to the user (e.g. when creating plots, tables, or files).\n\n" }}
+ {{- "When you send a message containing Python code to python, it will be executed in a stateful Jupyter notebook environment. python will respond with the output of the execution or time out after 120.0 seconds. The drive at '/mnt/data' can be used to save and persist user files. Internet access for this session is UNKNOWN. Depends on the cluster.\n\n" }}
+ {%- endif -%}
+{%- endmacro -%}
+
+{#- System Message Construction ============================================ #}
+{%- macro build_system_message() -%}
+ {%- if model_identity is not defined %}
+ {%- set model_identity = "You are LLM-jp-4, a large language model trained by LLM-jp." %}
+ {%- endif %}
+ {{- model_identity + "\n" -}}
+ {% if knowledge_cutoff is not defined %}
+ {%- set knowledge_cutoff = "2025-12" %}
+ {%- endif %}
+ {{- "Knowledge cutoff: " + knowledge_cutoff + "\n" -}}
+ {% if conversation_start_date is not defined %}
+ {%- set conversation_start_date = strftime_now("%Y-%m-%d") %}
+ {%- endif %}
+ {{- "Current date: " + conversation_start_date + "\n\n" }}
+ {%- if reasoning_effort is not defined %}
+ {%- set reasoning_effort = "medium" %}
+ {%- endif %}
+ {{- "Reasoning: " + reasoning_effort + "\n\n" }}
+ {%- if builtin_tools %}
+ {{- "# Tools\n\n" }}
+ {%- set available_builtin_tools = namespace(browser=false, python=false) %}
+ {%- for tool in builtin_tools %}
+ {%- if tool == "browser" %}
+ {%- set available_builtin_tools.browser = true %}
+ {%- elif tool == "python" %}
+ {%- set available_builtin_tools.python = true %}
+ {%- endif %}
+ {%- endfor %}
+ {{- render_builtin_tools(available_builtin_tools.browser, available_builtin_tools.python) }}
+ {%- endif -%}
+ {{- "# Valid channels: analysis, commentary, final. Channel must be included for every message." }}
+ {%- if tools -%}
+ {{- "\nCalls to these tools must go to the commentary channel: 'functions'." }}
+ {%- endif -%}
+{%- endmacro -%}
+
+{#- Main Template Logic ================================================= #}
+{#- Set defaults #}
+
+{#- Render system message #}
+{{- "<|start|>system<|message|>" }}
+{{- build_system_message() }}
+{{- "<|end|>" }}
+
+{#- Extract developer message #}
+{%- if messages[0].role == "developer" or messages[0].role == "system" %}
+ {%- set developer_message = messages[0].content %}
+ {%- set loop_messages = messages[1:] %}
+{%- else %}
+ {%- set developer_message = "" %}
+ {%- set loop_messages = messages %}
+{%- endif %}
+
+{#- Render developer message #}
+{%- if developer_message or tools %}
+ {{- "<|start|>developer<|message|>" }}
+ {%- if developer_message %}
+ {{- "# Instructions\n\n" }}
+ {{- developer_message }}
+ {{- "\n\n" }}
+ {%- endif %}
+ {%- if tools -%}
+ {{- "# Tools\n\n" }}
+ {{- render_tool_namespace("functions", tools) }}
+ {%- endif -%}
+ {{- "<|end|>" }}
+{%- endif %}
+
+{#- Render messages #}
+{#- tool_group: call names of the latest assistant tool_calls message, in call order, #}
+{#- plus how many of their results have been rendered (nameless results are attributed by order) #}
+{%- set last_tool_call = namespace(name=none) %}
+{%- set tool_group = namespace(names=[], result_idx=0) %}
+{%- for message in loop_messages -%}
+ {#- At this point only assistant/user/tool messages should remain #}
+ {%- if message.role == 'assistant' -%}
+ {#- Checks to ensure the messages are being passed in the format we expect #}
+ {%- if "content" in message %}
+ {%- if "<|channel|>analysis<|message|>" in message.content or "<|channel|>final<|message|>" in message.content %}
+ {{- raise_exception("You have passed a message containing <|channel|> tags in the content field. Instead of doing this, you should pass analysis messages (the string between '<|message|>' and '<|end|>') in the 'thinking' field, and final messages (the string between '<|message|>' and '<|end|>') in the 'content' field.") }}
+ {%- endif %}
+ {%- endif %}
+ {%- if "thinking" in message %}
+ {%- if "<|channel|>analysis<|message|>" in message.thinking or "<|channel|>final<|message|>" in message.thinking %}
+ {{- raise_exception("You have passed a message containing <|channel|> tags in the thinking field. Instead of doing this, you should pass analysis messages (the string between '<|message|>' and '<|end|>') in the 'thinking' field, and final messages (the string between '<|message|>' and '<|end|>') in the 'content' field.") }}
+ {%- endif %}
+ {%- endif %}
+ {%- if "tool_calls" in message %}
+ {#- Drop-all: previous-turn analysis/CoT is never rendered. It is emitted only for the #}
+ {#- training target (last message, add_generation_prompt=false), once before the calls. #}
+ {%- if message.content and message.thinking %}
+ {{- raise_exception("Cannot pass both content and thinking in an assistant message with tool calls! Put the analysis message in one or the other, but not both.") }}
+ {%- elif message.content and loop.last and not add_generation_prompt %}
+ {{- "<|start|>assistant<|channel|>analysis<|message|>" + message.content + "<|end|>" }}
+ {%- elif message.thinking and loop.last and not add_generation_prompt %}
+ {{- "<|start|>assistant<|channel|>analysis<|message|>" + message.thinking + "<|end|>" }}
+ {%- endif %}
+ {#- Parallel tool calls: every call is rendered; all but the last end with <|end|>, #}
+ {#- the last with <|call|>. A single call renders as in the non-parallel template. #}
+ {%- set tool_group.names = [] %}
+ {%- set tool_group.result_idx = 0 %}
+ {%- for raw_tool_call in message.tool_calls %}
+ {%- set tool_call = raw_tool_call.function if raw_tool_call.function else raw_tool_call %}
+ {{- "<|start|>assistant to=" }}
+ {{- "functions." + tool_call.name + "<|channel|>commentary " }}
+ {#- content_type default must match the training data ("<|constrain|> json") #}
+ {{- (tool_call.content_type if tool_call.content_type is defined else "<|constrain|> json") + "<|message|>" }}
+ {#- String arguments are already JSON: emit verbatim; only dict arguments need |tojson #}
+ {{- tool_call.arguments if tool_call.arguments is string else tool_call.arguments|tojson }}
+ {%- if loop.last %}
+ {{- "<|call|>" }}
+ {%- else %}
+ {{- "<|end|>" }}
+ {%- endif %}
+ {%- set last_tool_call.name = tool_call.name %}
+ {%- set tool_group.names = tool_group.names + [tool_call.name] %}
+ {%- endfor %}
+ {%- elif loop.last and not add_generation_prompt %}
+ {#- Only render the CoT if the final turn is an assistant turn and add_generation_prompt is false #}
+ {#- This is a situation that should only occur in training, never in inference. #}
+ {%- if "thinking" in message %}
+ {{- "<|start|>assistant<|channel|>analysis<|message|>" + message.thinking + "<|end|>" }}
+ {%- endif %}
+ {#- <|return|> indicates the end of generation, but <|end|> does not #}
+ {#- <|return|> should never be an input to the model, but we include it as the final token #}
+ {#- when training, so the model learns to emit it. #}
+ {{- "<|start|>assistant<|channel|>final<|message|>" + message.content + "<|return|>" }}
+ {%- else %}
+ {#- CoT is dropped during all previous turns, so we never render it for inference #}
+ {{- "<|start|>assistant<|channel|>final<|message|>" + message.content + "<|end|>" }}
+ {%- set last_tool_call.name = none %}
+ {%- endif %}
+ {%- elif message.role == 'tool' -%}
+ {#- Tool name: message.name if given, else by position in the current call group #}
+ {#- (call order == result order), else the last call (legacy fallback). #}
+ {%- if message.name is defined and message.name %}
+ {%- set tool_name = message.name %}
+ {%- elif tool_group.result_idx < tool_group.names|length %}
+ {%- set tool_name = tool_group.names[tool_group.result_idx] %}
+ {%- else %}
+ {%- set tool_name = last_tool_call.name %}
+ {%- endif %}
+ {%- set tool_group.result_idx = tool_group.result_idx + 1 %}
+ {%- if tool_name is none %}
+ {{- raise_exception("Message has tool role, but could not resolve its source function name (no 'name' field and no preceding assistant tool call).") }}
+ {%- endif %}
+ {{- "<|start|>functions." + tool_name }}
+ {{- " to=assistant<|channel|>commentary<|message|>" + message.content|tojson + "<|end|>" }}
+ {%- elif message.role == 'user' -%}
+ {{- "<|start|>user<|message|>" + message.content + "<|end|>" }}
+ {%- endif -%}
+{%- endfor -%}
+
+{#- Generation prompt #}
+{%- if add_generation_prompt -%}
+<|start|>assistant
+{%- endif -%}
\ No newline at end of file
diff --git a/tests/test-chat.cpp b/tests/test-chat.cpp
index 6b8b85616..d0fe08585 100644
--- a/tests/test-chat.cpp
+++ b/tests/test-chat.cpp
@@ -6601,6 +6601,76 @@ static void test_template_output_peg_parsers(bool detailed_debug) {
.run();
}
+ // LLM-jp-4.1: GPT-OSS dialect with spaces after special tokens and <|end|>-separated parallel calls
+ {
+ auto tst = peg_tester("models/templates/llm-jp-llm-jp-4.1-8b-thinking.jinja", detailed_debug);
+
+ // Final channel
+ tst.test("<|channel|> final<|message|> Hello, world!\nWhat's up?").expect(message_assist).run();
+
+ // One space rule: an intentional leading space survives
+ tst.test("<|channel|> final<|message|> padded").expect_content(" padded").run();
+
+ // Reasoning + content
+ tst.test(
+ "<|channel|> analysis<|message|> I'm\nthinking<|end|><|start|> assistant<|channel|> final<|message|> Hello, world!\nWhat's "
+ "up?")
+ .reasoning_format(COMMON_REASONING_FORMAT_AUTO)
+ .expect(message_assist_thoughts)
+ .run();
+
+ // Partial reasoning
+ tst.test("<|channel|> analysis<|message|> I'm\nthinking")
+ .reasoning_format(COMMON_REASONING_FORMAT_AUTO)
+ .is_partial(true)
+ .expect_reasoning("I'm\nthinking")
+ .run();
+
+ // Tool call, recipient in role header
+ tst.test(
+ "<|channel|> analysis<|message|> I'm\nthinking<|end|>"
+ "<|start|> assistant to=functions.special_function<|channel|> commentary <|constrain|> json<|message|> {\"arg1\": 1}")
+ .reasoning_format(COMMON_REASONING_FORMAT_AUTO)
+ .tools({ special_function_tool })
+ .expect(message_assist_call_thoughts)
+ .run();
+
+ // Tool call, recipient in channel header
+ tst.test("<|channel|> commentary to=functions.special_function<|message|> {\"arg1\": 1}")
+ .reasoning_format(COMMON_REASONING_FORMAT_AUTO)
+ .tools({ special_function_tool })
+ .expect(message_assist_call)
+ .run();
+
+ // Parallel tool calls separated by <|end|>
+ tst.test(
+ "<|channel|> analysis<|message|> I'm\nthinking<|end|>"
+ "<|start|> assistant to=functions.special_function<|channel|> commentary <|constrain|> json<|message|> {\"arg1\": 1}<|end|>"
+ "<|start|> assistant to=functions.special_function<|channel|> commentary <|constrain|> json<|message|> {\"arg1\": 2}")
+ .reasoning_format(COMMON_REASONING_FORMAT_AUTO)
+ .tools({ special_function_tool })
+ .parallel_tool_calls(true)
+ .expect_reasoning("I'm\nthinking")
+ .expect_tool_calls({
+ { "special_function", "{\"arg1\": 1}", {} },
+ { "special_function", "{\"arg1\": 2}", {} },
+ })
+ .run();
+
+ // Structured output
+ tst.test(
+ "<|channel|> analysis<|message|> I need to output the invoice details in JSON<|end|>"
+ "<|start|> assistant<|channel|> final <|constrain|> json"
+ "<|message|> "
+ R"({"amount": 123.45, "date": "2025-12-03"})"
+ )
+ .reasoning_format(COMMON_REASONING_FORMAT_AUTO)
+ .json_schema(invoice_schema)
+ .expect_reasoning("I need to output the invoice details in JSON")
+ .expect_content(R"({"amount": 123.45, "date": "2025-12-03"})")
+ .run();
+ }
+
{
auto tst = peg_tester("models/templates/StepFun3.5-Flash.jinja", detailed_debug);