Upload chat_template.jinja

chat_template.jinja

@@ -1,3 +1,4 @@
+{#- chat_format=llm-jp-harmony-v1 -#}
 {#-
   In addition to the normal inputs of `messages` and `tools`, this template also accepts the
   following kwargs:
@@ -261,12 +262,8 @@
 {%- endif %}
 
 {#- Render messages #}
-{#- tool_group tracks the names of the calls in the most recent assistant tool_calls #}
-{#- message (in call order) and how many of their results have been rendered, so tool #}
-{#- results that arrive without a "name" field (all OpenAI clients: they only carry #}
-{#- tool_call_id) can be attributed positionally -- the same by-order convention the #}
-{#- training tokenizer uses. Falling back to last_tool_call.name instead would label #}
-{#- every result of a parallel batch with the LAST call's function name. #}
+{#- 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 -%}
@@ -284,51 +281,26 @@
             {%- endif %}
         {%- endif %}
         {%- if "tool_calls" in message %}
-            {#- We need very careful handling here - we want to drop the tool call analysis message if the model #}
-            {#- has output a later <|final|> message, but otherwise we want to retain it. This is the only case #}
-            {#- when we render CoT/analysis messages in inference. #}
-            {%- set future_final_message = namespace(found=false) %}
-            {#- A later final closes this tool loop and drops its reasoning -- but only #}
-            {#- if that final is NOT the last message. When the final IS last, we are #}
-            {#- rendering the training target that closes the loop: the model generated #}
-            {#- that final WITH the in-loop reasoning still in context, so the render #}
-            {#- must keep it (otherwise the prompt render is not a prefix of the full #}
-            {#- render and the loss mask is corrupted). At inference a history final is #}
-            {#- always followed by at least a user message, so behavior is unchanged. #}
-            {%- for future_message in loop_messages[loop.index:] %}
-                {%- if future_message.role == 'assistant' and "tool_calls" not in future_message and not loop.last %}
-                    {%- set future_final_message.found = true %}
-                {%- endif %}
-            {%- endfor %}
-            {#- Render the analysis/CoT once, before the (possibly parallel) batch of calls. #}
+            {#- 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 not future_final_message.found %}
+            {%- elif message.content and loop.last and not add_generation_prompt %}
                 {{- "<|start|>assistant<|channel|>analysis<|message|>" + message.content + "<|end|>" }}
-            {%- elif message.thinking and not future_final_message.found %}
+            {%- elif message.thinking and loop.last and not add_generation_prompt %}
                 {{- "<|start|>assistant<|channel|>analysis<|message|>" + message.thinking + "<|end|>" }}
             {%- endif %}
-            {#- Parallel tool calling: render every call in message.tool_calls. All calls #}
-            {#- except the last terminate with <|end|> (a continuation token, so sampling #}
-            {#- does not stop); only the final call terminates with <|call|> (the dispatch #}
-            {#- /stop token). A message with a single tool call therefore renders identically #}
-            {#- to the non-parallel template. #}
+            {#- 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 " }}
-                {#- Default content_type must match the training data, which always carries #}
-                {#- "<|constrain|> json" on every assistant call. OpenAI clients never send #}
-                {#- content_type, so a bare "json" default would replay prior calls into the #}
-                {#- context in a header form the model never saw during training. #}
+                {#- 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|>" }}
-                {#- Arguments are already a JSON string in our data/inference inputs, so emit #}
-                {#- them verbatim. Applying |tojson to a string would re-encode it as a quoted, #}
-                {#- escaped string literal (e.g. "{\"city\": \"x\"}"), which is non-standard #}
-                {#- harmony and forces the serving wrapper into fragile unescaping. Only dict #}
-                {#- arguments (some OpenAI clients) need |tojson. #}
+                {#- 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|>" }}
@@ -354,10 +326,8 @@
             {%- set last_tool_call.name = none %}
         {%- endif %}
     {%- elif message.role == 'tool' -%}
-        {#- Prefer the source function name carried on the tool message itself (the tokenizer #}
-        {#- tags each parallel result with its own call name); otherwise attribute results #}
-        {#- positionally within the current call group (call order == result order, the #}
-        {#- training convention); last_tool_call.name remains only as a legacy fallback. #}
+        {#- 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 %}