402 KiB
402 KiB
================================================================================
TEMPLATE ANALYSIS TOOL
================================================================================
Analyzing 37 template(s)
================================================================================
ANALYZING TEMPLATE: models/templates/Apertus-8B-Instruct.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<|system_start|>You are Apertus, a helpful assistant created by the SwissAI initiative.
Knowledge cutoff: 2024-04
Current date: 2026-01-26<|system_end|><|developer_start|>Deliberation: enabled
Tool Capabilities:'
Common Suffix: '<|developer_end|><|user_start|>Hello, please help me.<|user_end|>'
Left (difference): ' disabled'
Right (difference): '
//
type = () => any;'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<|system_start|>You are Apertus, a helpful assistant created by the SwissAI initiative.
Knowledge cutoff: 2024-04
Current date: 2026-01-26<|system_end|><|developer_start|>Deliberation: enabled
Tool Capabilities: disabled<|developer_end|><|user_start|>Hello, please help me.<|user_end|>'
Common Suffix: ''
Left (difference): ''
Right (difference): '<|assistant_start|>'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<|system_start|>You are Apertus, a helpful assistant created by the SwissAI initiative.
Knowledge cutoff: 2024-04
Current date: 2026-01-26<|system_end|><|developer_start|>Deliberation: enabled
Tool Capabilities: disabled<|developer_end|><|user_start|>Hello, please help me.<|user_end|><|assistant_start|>I can help you with that.'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<|system_start|>You are Apertus, a helpful assistant created by the SwissAI initiative.
Knowledge cutoff: 2024-04
Current date: 2026-01-26<|system_end|><|developer_start|>Deliberation: enabled
Tool Capabilities: disabled<|developer_end|><|user_start|>Hello, please help me.<|user_end|><|assistant_start|>I can help you with that.<|assistant_end|><|user_start|>Thank you.<|user_end|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<|system_start|>You are Apertus, a helpful assistant created by the SwissAI initiative.
Knowledge cutoff: 2024-04
Current date: 2026-01-26<|system_end|><|developer_start|>Deliberation: enabled
Tool Capabilities:
//
type = () => any;<|developer_end|><|user_start|>Hello, please help me.<|user_end|><|assistant_start|>'
Common Suffix: ''
Left (difference): 'Let me help you.'
Right (difference): '<|tools_prefix|>[{"test_function_name": {"param1":0x6414d8ab7770, "param2":0x6414d8b07d80}}]<|tools_suffix|>'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<|system_start|>You are Apertus, a helpful assistant created by the SwissAI initiative.
Knowledge cutoff: 2024-04
Current date: 2026-01-26<|system_end|><|developer_start|>Deliberation: enabled
Tool Capabilities:
//
type = () => any;<|developer_end|><|user_start|>Hello, please help me.<|user_end|><|assistant_start|>'
Common Suffix: '<|assistant_end|><|user_start|>Continue.<|user_end|>'
Left (difference): 'Let me help you.'
Right (difference): '<|tools_prefix|>[{"test_function_name": {"param1":0x6414d8b0a5f0, "param2":0x6414d8b03350}}]<|tools_suffix|>'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '<|system_start|>You are Apertus, a helpful assistant created by the SwissAI initiative.
Knowledge cutoff: 2024-04
Current date: 2026-01-26<|system_end|><|developer_start|>Deliberation: enabled
Tool Capabilities:
//
type = () => any;<|developer_end|><|user_start|>Hello, please help me.<|user_end|><|assistant_start|><|tools_prefix|>[{"test_function_name": {"param1":0x6414d8ab'
Common Suffix: '0}}]<|tools_suffix|>'
Left (difference): '8210, "param2":0x6414d8b1315'
Right (difference): '7220, "param2":0x6414d8b06690}}, {"test_function_name": {"param1":0x6414d8ae81e0, "param2":0x6414d8b0d43'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '<|system_start|>You are Apertus, a helpful assistant created by the SwissAI initiative.
Knowledge cutoff: 2024-04
Current date: 2026-01-26<|system_end|><|developer_start|>Deliberation: enabled
Tool Capabilities:
//
type = () => any;<|developer_end|><|user_start|>Hello, please help me.<|user_end|><|assistant_start|><|tools_prefix|>[{"test_function_name": {"param1":0x6414d8b0'
Common Suffix: '0}}]<|tools_suffix|><|assistant_end|><|user_start|>Continue.<|user_end|>'
Left (difference): '6690, "param2":0x6414d8b0e31'
Right (difference): 'd430, "param2":0x6414d8b06540}}, {"test_function_name": {"param1":0x6414d8b04530, "param2":0x6414d8b05b8'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '<|system_start|>You are Apertus, a helpful assistant created by the SwissAI initiative.
Knowledge cutoff: 2024-04
Current date: 2026-01-26<|system_end|><|developer_start|>Deliberation: enabled
Tool Capabilities:
//
type = () => any;<|developer_end|><|user_start|>Hello, please help me.<|user_end|><|assistant_start|><|tools_prefix|>[{"test_function_name": {"param1":0x6414d8'
Common Suffix: '0}}]<|tools_suffix|>'
Left (difference): 'b05b80, "param2":0x6414d8b0a1c'
Right (difference): 'ae81e0, "param2":0x6414d8b0d43'
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/Apriel-1.6-15b-Thinker-fixed.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<|begin_system|>
You are a thoughtful, systematic AI assistant from ServiceNow Language Models (SLAM) lab.
Analyze each question carefully, present your reasoning step-by-step, then provide the final
response after the marker [BEGIN FINAL RESPONSE].
'
Common Suffix: '<|begin_user|>
Hello, please help me.
<|begin_assistant|>
Here are my reasoning steps:
'
Left (difference): ''
Right (difference): 'You are provided with function signatures within <available_tools></available_tools> XML tags.
You may call one or more functions to assist with the user query.
Don't make assumptions about the arguments. You should infer the argument values from previous
user responses and the system message.
Here are the available tools:
<available_tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</available_tools>.
Return all function calls as a list of JSON objects within <tool_calls></tool_calls> XML tags.
Each JSON object should contain a function name and arguments as follows:
<tool_calls>[
{"name": <function-name-1>, "arguments": <args-dict-1>},
{"name": <function-name-2>, "arguments": <args-dict-2>},
...
]</tool_calls>
'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<|begin_system|>
You are a thoughtful, systematic AI assistant from ServiceNow Language Models (SLAM) lab.
Analyze each question carefully, present your reasoning step-by-step, then provide the final
response after the marker [BEGIN FINAL RESPONSE].
<|begin_user|>
Hello, please help me.
<|begin_assistant|>
Here are my reasoning steps:
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<|begin_system|>
You are a thoughtful, systematic AI assistant from ServiceNow Language Models (SLAM) lab.
Analyze each question carefully, present your reasoning step-by-step, then provide the final
response after the marker [BEGIN FINAL RESPONSE].
<|begin_user|>
Hello, please help me.
<|begin_assistant|>
'
Common Suffix: 'I can help you with that.'
Left (difference): ''
Right (difference): 'The user is asking for help. I should respond positively.
[BEGIN FINAL RESPONSE]
'
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<|begin_system|>
You are a thoughtful, systematic AI assistant from ServiceNow Language Models (SLAM) lab.
Analyze each question carefully, present your reasoning step-by-step, then provide the final
response after the marker [BEGIN FINAL RESPONSE].
<|begin_user|>
Hello, please help me.
<|begin_assistant|>
I can help you with that.
<|end|>
<|begin_user|>
Thank you.
<|begin_assistant|>
Here are my reasoning steps:
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<|begin_system|>
You are a thoughtful, systematic AI assistant from ServiceNow Language Models (SLAM) lab.
Analyze each question carefully, present your reasoning step-by-step, then provide the final
response after the marker [BEGIN FINAL RESPONSE].
You are provided with function signatures within <available_tools></available_tools> XML tags.
You may call one or more functions to assist with the user query.
Don't make assumptions about the arguments. You should infer the argument values from previous
user responses and the system message.
Here are the available tools:
<available_tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</available_tools>.
Return all function calls as a list of JSON objects within <tool_calls></tool_calls> XML tags.
Each JSON object should contain a function name and arguments as follows:
<tool_calls>[
{"name": <function-name-1>, "arguments": <args-dict-1>},
{"name": <function-name-2>, "arguments": <args-dict-2>},
...
]</tool_calls>
<|begin_user|>
Hello, please help me.
<|begin_assistant|>
'
Common Suffix: ''
Left (difference): 'Let me help you.'
Right (difference): '
<tool_calls>[{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}]</tool_calls>'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<|begin_system|>
You are a thoughtful, systematic AI assistant from ServiceNow Language Models (SLAM) lab.
Analyze each question carefully, present your reasoning step-by-step, then provide the final
response after the marker [BEGIN FINAL RESPONSE].
You are provided with function signatures within <available_tools></available_tools> XML tags.
You may call one or more functions to assist with the user query.
Don't make assumptions about the arguments. You should infer the argument values from previous
user responses and the system message.
Here are the available tools:
<available_tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</available_tools>.
Return all function calls as a list of JSON objects within <tool_calls></tool_calls> XML tags.
Each JSON object should contain a function name and arguments as follows:
<tool_calls>[
{"name": <function-name-1>, "arguments": <args-dict-1>},
{"name": <function-name-2>, "arguments": <args-dict-2>},
...
]</tool_calls>
<|begin_user|>
Hello, please help me.
<|begin_assistant|>
'
Common Suffix: '
<|end|>
<|begin_user|>
Continue.
<|begin_assistant|>
Here are my reasoning steps:
'
Left (difference): 'Let me help you.'
Right (difference): '
<tool_calls>[{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}, "id": "call_001"}]</tool_calls>'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '<|begin_system|>
You are a thoughtful, systematic AI assistant from ServiceNow Language Models (SLAM) lab.
Analyze each question carefully, present your reasoning step-by-step, then provide the final
response after the marker [BEGIN FINAL RESPONSE].
You are provided with function signatures within <available_tools></available_tools> XML tags.
You may call one or more functions to assist with the user query.
Don't make assumptions about the arguments. You should infer the argument values from previous
user responses and the system message.
Here are the available tools:
<available_tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</available_tools>.
Return all function calls as a list of JSON objects within <tool_calls></tool_calls> XML tags.
Each JSON object should contain a function name and arguments as follows:
<tool_calls>[
{"name": <function-name-1>, "arguments": <args-dict-1>},
{"name": <function-name-2>, "arguments": <args-dict-2>},
...
]</tool_calls>
<|begin_user|>
Hello, please help me.
<|begin_assistant|>
<tool_calls>[{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}'
Common Suffix: ']</tool_calls>'
Left (difference): ''
Right (difference): ', {"name": "test_function_name", "arguments": {"param1": "value3", "param2": "value4"}}'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '<|begin_system|>
You are a thoughtful, systematic AI assistant from ServiceNow Language Models (SLAM) lab.
Analyze each question carefully, present your reasoning step-by-step, then provide the final
response after the marker [BEGIN FINAL RESPONSE].
You are provided with function signatures within <available_tools></available_tools> XML tags.
You may call one or more functions to assist with the user query.
Don't make assumptions about the arguments. You should infer the argument values from previous
user responses and the system message.
Here are the available tools:
<available_tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</available_tools>.
Return all function calls as a list of JSON objects within <tool_calls></tool_calls> XML tags.
Each JSON object should contain a function name and arguments as follows:
<tool_calls>[
{"name": <function-name-1>, "arguments": <args-dict-1>},
{"name": <function-name-2>, "arguments": <args-dict-2>},
...
]</tool_calls>
<|begin_user|>
Hello, please help me.
<|begin_assistant|>
<tool_calls>[{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}, "id": "call_001"}'
Common Suffix: ']</tool_calls>
<|end|>
<|begin_user|>
Continue.
<|begin_assistant|>
Here are my reasoning steps:
'
Left (difference): ''
Right (difference): ', {"name": "test_function_name", "arguments": {"param1": "value3", "param2": "value4"}, "id": "call_002"}'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '<|begin_system|>
You are a thoughtful, systematic AI assistant from ServiceNow Language Models (SLAM) lab.
Analyze each question carefully, present your reasoning step-by-step, then provide the final
response after the marker [BEGIN FINAL RESPONSE].
You are provided with function signatures within <available_tools></available_tools> XML tags.
You may call one or more functions to assist with the user query.
Don't make assumptions about the arguments. You should infer the argument values from previous
user responses and the system message.
Here are the available tools:
<available_tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</available_tools>.
Return all function calls as a list of JSON objects within <tool_calls></tool_calls> XML tags.
Each JSON object should contain a function name and arguments as follows:
<tool_calls>[
{"name": <function-name-1>, "arguments": <args-dict-1>},
{"name": <function-name-2>, "arguments": <args-dict-2>},
...
]</tool_calls>
<|begin_user|>
Hello, please help me.
<|begin_assistant|>
'
Common Suffix: '
<tool_calls>[{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}]</tool_calls>'
Left (difference): ''
Right (difference): 'I need to call the tool first.
[BEGIN FINAL RESPONSE]
'
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/ByteDance-Seed-OSS.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: true
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<seed:bos>'
Common Suffix: 'user
Hello, please help me.<seed:eos>'
Left (difference): ''
Right (difference): 'system
You are Doubao, a helpful AI assistant. You may call one or more functions to assist with the user query.
Function:
def test_function_name(param1: str,param2: str):
"""
A test function for debugging
Args:
- param1 (str) [必填]: First parameter
- param2 (str) [必填]: Second parameter
"""
工具调用请遵循如下格式:
<seed: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>
</seed:tool_call>
<seed:eos><seed:bos>'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<seed:bos>user
Hello, please help me.<seed:eos>'
Common Suffix: ''
Left (difference): ''
Right (difference): '<seed:bos>assistant
'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<seed:bos>user
Hello, please help me.<seed:eos><seed:bos>assistant
'
Common Suffix: 'I can help you with that.<seed:eos>'
Left (difference): ''
Right (difference): '<seed:think>The user is asking for help. I should respond positively.</seed:think>
'
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<seed:bos>user
Hello, please help me.<seed:eos><seed:bos>assistant
'
Common Suffix: 'I can help you with that.<seed:eos><seed:bos>user
Thank you.<seed:eos>'
Left (difference): ''
Right (difference): '<seed:think>The user is asking for help. I should respond positively.</seed:think>
'
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<seed:bos>system
You are Doubao, a helpful AI assistant. You may call one or more functions to assist with the user query.
Function:
def test_function_name(param1: str,param2: str):
"""
A test function for debugging
Args:
- param1 (str) [必填]: First parameter
- param2 (str) [必填]: Second parameter
"""
工具调用请遵循如下格式:
<seed: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>
</seed:tool_call>
<seed:eos><seed:bos>user
Hello, please help me.<seed:eos><seed:bos>assistant
'
Common Suffix: '<seed:eos>'
Left (difference): 'Let me help you.'
Right (difference): '<seed:tool_call>
<function=test_function_name>
<parameter=param1>value1</parameter>
<parameter=param2>value2</parameter>
</function>
</seed:tool_call>'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<seed:bos>system
You are Doubao, a helpful AI assistant. You may call one or more functions to assist with the user query.
Function:
def test_function_name(param1: str,param2: str):
"""
A test function for debugging
Args:
- param1 (str) [必填]: First parameter
- param2 (str) [必填]: Second parameter
"""
工具调用请遵循如下格式:
<seed: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>
</seed:tool_call>
<seed:eos><seed:bos>user
Hello, please help me.<seed:eos><seed:bos>assistant
'
Common Suffix: '<seed:eos><seed:bos>user
Continue.<seed:eos>'
Left (difference): 'Let me help you.'
Right (difference): '<seed:tool_call>
<function=test_function_name>
<parameter=param1>value1</parameter>
<parameter=param2>value2</parameter>
</function>
</seed:tool_call>'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '<seed:bos>system
You are Doubao, a helpful AI assistant. You may call one or more functions to assist with the user query.
Function:
def test_function_name(param1: str,param2: str):
"""
A test function for debugging
Args:
- param1 (str) [必填]: First parameter
- param2 (str) [必填]: Second parameter
"""
工具调用请遵循如下格式:
<seed: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>
</seed:tool_call>
<seed:eos><seed:bos>user
Hello, please help me.<seed:eos><seed:bos>assistant
<seed:tool_call>
<function=test_function_name>
<parameter=param1>value1</parameter>
<parameter=param2>value2</parameter>
</function>
</seed:tool_call>'
Common Suffix: '<seed:eos>'
Left (difference): ''
Right (difference): '
<seed:tool_call>
<function=test_function_name>
<parameter=param1>value3</parameter>
<parameter=param2>value4</parameter>
</function>
</seed:tool_call>'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '<seed:bos>system
You are Doubao, a helpful AI assistant. You may call one or more functions to assist with the user query.
Function:
def test_function_name(param1: str,param2: str):
"""
A test function for debugging
Args:
- param1 (str) [必填]: First parameter
- param2 (str) [必填]: Second parameter
"""
工具调用请遵循如下格式:
<seed: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>
</seed:tool_call>
<seed:eos><seed:bos>user
Hello, please help me.<seed:eos><seed:bos>assistant
<seed:tool_call>
<function=test_function_name>
<parameter=param1>value1</parameter>
<parameter=param2>value2</parameter>
</function>
</seed:tool_call>'
Common Suffix: '<seed:eos><seed:bos>user
Continue.<seed:eos>'
Left (difference): ''
Right (difference): '
<seed:tool_call>
<function=test_function_name>
<parameter=param1>value3</parameter>
<parameter=param2>value4</parameter>
</function>
</seed:tool_call>'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '<seed:bos>system
You are Doubao, a helpful AI assistant. You may call one or more functions to assist with the user query.
Function:
def test_function_name(param1: str,param2: str):
"""
A test function for debugging
Args:
- param1 (str) [必填]: First parameter
- param2 (str) [必填]: Second parameter
"""
工具调用请遵循如下格式:
<seed: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>
</seed:tool_call>
<seed:eos><seed:bos>user
Hello, please help me.<seed:eos><seed:bos>assistant
'
Common Suffix: '<seed:tool_call>
<function=test_function_name>
<parameter=param1>value1</parameter>
<parameter=param2>value2</parameter>
</function>
</seed:tool_call><seed:eos>'
Left (difference): ''
Right (difference): '<seed:think>I need to call the tool first.</seed:think>
'
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/CohereForAI-c4ai-command-r-plus-tool_use.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: true
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|># Safety Preamble
The instructions in this section override those in the task description and style guide sections. Don't answer questions that are harmful or immoral.
# System Preamble
## Basic Rules
You are a powerful conversational AI trained by Cohere to help people. You are augmented by a number of tools, and your job is to use and consume the output of these tools to best help the user. You will see a conversation history between yourself and a user, ending with an utterance from the user. You will then see a specific instruction instructing you what kind of response to generate. When you answer the user's requests, you cite your sources in your answers, according to those instructions.
# User Preamble
## Task and Context
You help people answer their questions and other requests interactively. You will be asked a very wide array of requests on all kinds of topics. You will be equipped with a wide range of search engines or similar tools to help you, which you use to research your answer. You should focus on serving the user's needs as best you can, which will be wide-ranging.
## Style Guide
Unless the user asks for a different style of answer, you should answer in full sentences, using proper grammar and spelling.
## Available Tools
Here is a list of tools that you have available to you:
'
Common Suffix: '<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, please help me.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|>Write 'Action:' followed by a json-formatted list of actions that you want to perform in order to produce a good response to the user's last input. You can use any of the supplied tools any number of times, but you should aim to execute the minimum number of necessary actions for the input. You should use the `directly-answer` tool if calling the other tools is unnecessary. The list of actions you want to call should be formatted as a list of json objects, for example:
```json
[
{
"tool_name": title of the tool in the specification,
"parameters": a dict of parameters to input into the tool as they are defined in the specs, or {} if it takes no parameters
}
]```<|END_OF_TURN_TOKEN|>'
Left (difference): ''
Right (difference): '```python
def test_function_name(param1: str, param2: str) -> List[Dict]:
"""A test function for debugging
Args:
param1 (str): First parameter
param2 (str): Second parameter
"""
pass
```'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|># Safety Preamble
The instructions in this section override those in the task description and style guide sections. Don't answer questions that are harmful or immoral.
# System Preamble
## Basic Rules
You are a powerful conversational AI trained by Cohere to help people. You are augmented by a number of tools, and your job is to use and consume the output of these tools to best help the user. You will see a conversation history between yourself and a user, ending with an utterance from the user. You will then see a specific instruction instructing you what kind of response to generate. When you answer the user's requests, you cite your sources in your answers, according to those instructions.
# User Preamble
## Task and Context
You help people answer their questions and other requests interactively. You will be asked a very wide array of requests on all kinds of topics. You will be equipped with a wide range of search engines or similar tools to help you, which you use to research your answer. You should focus on serving the user's needs as best you can, which will be wide-ranging.
## Style Guide
Unless the user asks for a different style of answer, you should answer in full sentences, using proper grammar and spelling.
## Available Tools
Here is a list of tools that you have available to you:
<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, please help me.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|>Write 'Action:' followed by a json-formatted list of actions that you want to perform in order to produce a good response to the user's last input. You can use any of the supplied tools any number of times, but you should aim to execute the minimum number of necessary actions for the input. You should use the `directly-answer` tool if calling the other tools is unnecessary. The list of actions you want to call should be formatted as a list of json objects, for example:
```json
[
{
"tool_name": title of the tool in the specification,
"parameters": a dict of parameters to input into the tool as they are defined in the specs, or {} if it takes no parameters
}
]```<|END_OF_TURN_TOKEN|>'
Common Suffix: ''
Left (difference): ''
Right (difference): '<|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|># Safety Preamble
The instructions in this section override those in the task description and style guide sections. Don't answer questions that are harmful or immoral.
# System Preamble
## Basic Rules
You are a powerful conversational AI trained by Cohere to help people. You are augmented by a number of tools, and your job is to use and consume the output of these tools to best help the user. You will see a conversation history between yourself and a user, ending with an utterance from the user. You will then see a specific instruction instructing you what kind of response to generate. When you answer the user's requests, you cite your sources in your answers, according to those instructions.
# User Preamble
## Task and Context
You help people answer their questions and other requests interactively. You will be asked a very wide array of requests on all kinds of topics. You will be equipped with a wide range of search engines or similar tools to help you, which you use to research your answer. You should focus on serving the user's needs as best you can, which will be wide-ranging.
## Style Guide
Unless the user asks for a different style of answer, you should answer in full sentences, using proper grammar and spelling.
## Available Tools
Here is a list of tools that you have available to you:
<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, please help me.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>I can help you with that.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|>Write 'Action:' followed by a json-formatted list of actions that you want to perform in order to produce a good response to the user's last input. You can use any of the supplied tools any number of times, but you should aim to execute the minimum number of necessary actions for the input. You should use the `directly-answer` tool if calling the other tools is unnecessary. The list of actions you want to call should be formatted as a list of json objects, for example:
```json
[
{
"tool_name": title of the tool in the specification,
"parameters": a dict of parameters to input into the tool as they are defined in the specs, or {} if it takes no parameters
}
]```<|END_OF_TURN_TOKEN|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|># Safety Preamble
The instructions in this section override those in the task description and style guide sections. Don't answer questions that are harmful or immoral.
# System Preamble
## Basic Rules
You are a powerful conversational AI trained by Cohere to help people. You are augmented by a number of tools, and your job is to use and consume the output of these tools to best help the user. You will see a conversation history between yourself and a user, ending with an utterance from the user. You will then see a specific instruction instructing you what kind of response to generate. When you answer the user's requests, you cite your sources in your answers, according to those instructions.
# User Preamble
## Task and Context
You help people answer their questions and other requests interactively. You will be asked a very wide array of requests on all kinds of topics. You will be equipped with a wide range of search engines or similar tools to help you, which you use to research your answer. You should focus on serving the user's needs as best you can, which will be wide-ranging.
## Style Guide
Unless the user asks for a different style of answer, you should answer in full sentences, using proper grammar and spelling.
## Available Tools
Here is a list of tools that you have available to you:
<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, please help me.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>I can help you with that.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Thank you.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|>Write 'Action:' followed by a json-formatted list of actions that you want to perform in order to produce a good response to the user's last input. You can use any of the supplied tools any number of times, but you should aim to execute the minimum number of necessary actions for the input. You should use the `directly-answer` tool if calling the other tools is unnecessary. The list of actions you want to call should be formatted as a list of json objects, for example:
```json
[
{
"tool_name": title of the tool in the specification,
"parameters": a dict of parameters to input into the tool as they are defined in the specs, or {} if it takes no parameters
}
]```<|END_OF_TURN_TOKEN|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|># Safety Preamble
The instructions in this section override those in the task description and style guide sections. Don't answer questions that are harmful or immoral.
# System Preamble
## Basic Rules
You are a powerful conversational AI trained by Cohere to help people. You are augmented by a number of tools, and your job is to use and consume the output of these tools to best help the user. You will see a conversation history between yourself and a user, ending with an utterance from the user. You will then see a specific instruction instructing you what kind of response to generate. When you answer the user's requests, you cite your sources in your answers, according to those instructions.
# User Preamble
## Task and Context
You help people answer their questions and other requests interactively. You will be asked a very wide array of requests on all kinds of topics. You will be equipped with a wide range of search engines or similar tools to help you, which you use to research your answer. You should focus on serving the user's needs as best you can, which will be wide-ranging.
## Style Guide
Unless the user asks for a different style of answer, you should answer in full sentences, using proper grammar and spelling.
## Available Tools
Here is a list of tools that you have available to you:
```python
def test_function_name(param1: str, param2: str) -> List[Dict]:
"""A test function for debugging
Args:
param1 (str): First parameter
param2 (str): Second parameter
"""
pass
```<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, please help me.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>'
Common Suffix: '<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|>Write 'Action:' followed by a json-formatted list of actions that you want to perform in order to produce a good response to the user's last input. You can use any of the supplied tools any number of times, but you should aim to execute the minimum number of necessary actions for the input. You should use the `directly-answer` tool if calling the other tools is unnecessary. The list of actions you want to call should be formatted as a list of json objects, for example:
```json
[
{
"tool_name": title of the tool in the specification,
"parameters": a dict of parameters to input into the tool as they are defined in the specs, or {} if it takes no parameters
}
]```<|END_OF_TURN_TOKEN|>'
Left (difference): 'Let me help you.<|END_OF_TURN_TOKEN|>'
Right (difference): '
Action:
```json
[
{
"tool_name": "test_function_name",
"parameters": {
"param1": "value1",
"param2": "value2"
}
}
]```
'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|># Safety Preamble
The instructions in this section override those in the task description and style guide sections. Don't answer questions that are harmful or immoral.
# System Preamble
## Basic Rules
You are a powerful conversational AI trained by Cohere to help people. You are augmented by a number of tools, and your job is to use and consume the output of these tools to best help the user. You will see a conversation history between yourself and a user, ending with an utterance from the user. You will then see a specific instruction instructing you what kind of response to generate. When you answer the user's requests, you cite your sources in your answers, according to those instructions.
# User Preamble
## Task and Context
You help people answer their questions and other requests interactively. You will be asked a very wide array of requests on all kinds of topics. You will be equipped with a wide range of search engines or similar tools to help you, which you use to research your answer. You should focus on serving the user's needs as best you can, which will be wide-ranging.
## Style Guide
Unless the user asks for a different style of answer, you should answer in full sentences, using proper grammar and spelling.
## Available Tools
Here is a list of tools that you have available to you:
```python
def test_function_name(param1: str, param2: str) -> List[Dict]:
"""A test function for debugging
Args:
param1 (str): First parameter
param2 (str): Second parameter
"""
pass
```<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, please help me.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>'
Common Suffix: '<|START_OF_TURN_TOKEN|><|USER_TOKEN|>Continue.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|>Write 'Action:' followed by a json-formatted list of actions that you want to perform in order to produce a good response to the user's last input. You can use any of the supplied tools any number of times, but you should aim to execute the minimum number of necessary actions for the input. You should use the `directly-answer` tool if calling the other tools is unnecessary. The list of actions you want to call should be formatted as a list of json objects, for example:
```json
[
{
"tool_name": title of the tool in the specification,
"parameters": a dict of parameters to input into the tool as they are defined in the specs, or {} if it takes no parameters
}
]```<|END_OF_TURN_TOKEN|>'
Left (difference): 'Let me help you.<|END_OF_TURN_TOKEN|>'
Right (difference): '
Action:
```json
[
{
"tool_name": "test_function_name",
"parameters": {
"param1": "value1",
"param2": "value2"
}
}
]```
'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|># Safety Preamble
The instructions in this section override those in the task description and style guide sections. Don't answer questions that are harmful or immoral.
# System Preamble
## Basic Rules
You are a powerful conversational AI trained by Cohere to help people. You are augmented by a number of tools, and your job is to use and consume the output of these tools to best help the user. You will see a conversation history between yourself and a user, ending with an utterance from the user. You will then see a specific instruction instructing you what kind of response to generate. When you answer the user's requests, you cite your sources in your answers, according to those instructions.
# User Preamble
## Task and Context
You help people answer their questions and other requests interactively. You will be asked a very wide array of requests on all kinds of topics. You will be equipped with a wide range of search engines or similar tools to help you, which you use to research your answer. You should focus on serving the user's needs as best you can, which will be wide-ranging.
## Style Guide
Unless the user asks for a different style of answer, you should answer in full sentences, using proper grammar and spelling.
## Available Tools
Here is a list of tools that you have available to you:
```python
def test_function_name(param1: str, param2: str) -> List[Dict]:
"""A test function for debugging
Args:
param1 (str): First parameter
param2 (str): Second parameter
"""
pass
```<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, please help me.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>
Action:
```json
[
{
"tool_name": "test_function_name",
"parameters": {
"param1": "value1",
"param2": "value2"
}
}'
Common Suffix: '
]```
<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|>Write 'Action:' followed by a json-formatted list of actions that you want to perform in order to produce a good response to the user's last input. You can use any of the supplied tools any number of times, but you should aim to execute the minimum number of necessary actions for the input. You should use the `directly-answer` tool if calling the other tools is unnecessary. The list of actions you want to call should be formatted as a list of json objects, for example:
```json
[
{
"tool_name": title of the tool in the specification,
"parameters": a dict of parameters to input into the tool as they are defined in the specs, or {} if it takes no parameters
}
]```<|END_OF_TURN_TOKEN|>'
Left (difference): ''
Right (difference): ',
{
"tool_name": "test_function_name",
"parameters": {
"param1": "value3",
"param2": "value4"
}
}'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|># Safety Preamble
The instructions in this section override those in the task description and style guide sections. Don't answer questions that are harmful or immoral.
# System Preamble
## Basic Rules
You are a powerful conversational AI trained by Cohere to help people. You are augmented by a number of tools, and your job is to use and consume the output of these tools to best help the user. You will see a conversation history between yourself and a user, ending with an utterance from the user. You will then see a specific instruction instructing you what kind of response to generate. When you answer the user's requests, you cite your sources in your answers, according to those instructions.
# User Preamble
## Task and Context
You help people answer their questions and other requests interactively. You will be asked a very wide array of requests on all kinds of topics. You will be equipped with a wide range of search engines or similar tools to help you, which you use to research your answer. You should focus on serving the user's needs as best you can, which will be wide-ranging.
## Style Guide
Unless the user asks for a different style of answer, you should answer in full sentences, using proper grammar and spelling.
## Available Tools
Here is a list of tools that you have available to you:
```python
def test_function_name(param1: str, param2: str) -> List[Dict]:
"""A test function for debugging
Args:
param1 (str): First parameter
param2 (str): Second parameter
"""
pass
```<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, please help me.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>
Action:
```json
[
{
"tool_name": "test_function_name",
"parameters": {
"param1": "value1",
"param2": "value2"
}
}'
Common Suffix: '
]```
<|START_OF_TURN_TOKEN|><|USER_TOKEN|>Continue.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|>Write 'Action:' followed by a json-formatted list of actions that you want to perform in order to produce a good response to the user's last input. You can use any of the supplied tools any number of times, but you should aim to execute the minimum number of necessary actions for the input. You should use the `directly-answer` tool if calling the other tools is unnecessary. The list of actions you want to call should be formatted as a list of json objects, for example:
```json
[
{
"tool_name": title of the tool in the specification,
"parameters": a dict of parameters to input into the tool as they are defined in the specs, or {} if it takes no parameters
}
]```<|END_OF_TURN_TOKEN|>'
Left (difference): ''
Right (difference): ',
{
"tool_name": "test_function_name",
"parameters": {
"param1": "value3",
"param2": "value4"
}
}'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|># Safety Preamble
The instructions in this section override those in the task description and style guide sections. Don't answer questions that are harmful or immoral.
# System Preamble
## Basic Rules
You are a powerful conversational AI trained by Cohere to help people. You are augmented by a number of tools, and your job is to use and consume the output of these tools to best help the user. You will see a conversation history between yourself and a user, ending with an utterance from the user. You will then see a specific instruction instructing you what kind of response to generate. When you answer the user's requests, you cite your sources in your answers, according to those instructions.
# User Preamble
## Task and Context
You help people answer their questions and other requests interactively. You will be asked a very wide array of requests on all kinds of topics. You will be equipped with a wide range of search engines or similar tools to help you, which you use to research your answer. You should focus on serving the user's needs as best you can, which will be wide-ranging.
## Style Guide
Unless the user asks for a different style of answer, you should answer in full sentences, using proper grammar and spelling.
## Available Tools
Here is a list of tools that you have available to you:
```python
def test_function_name(param1: str, param2: str) -> List[Dict]:
"""A test function for debugging
Args:
param1 (str): First parameter
param2 (str): Second parameter
"""
pass
```<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, please help me.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>
Action:
```json
[
{
"tool_name": "test_function_name",
"parameters": {
"param1": "value1",
"param2": "value2"
}
}
]```
<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|>Write 'Action:' followed by a json-formatted list of actions that you want to perform in order to produce a good response to the user's last input. You can use any of the supplied tools any number of times, but you should aim to execute the minimum number of necessary actions for the input. You should use the `directly-answer` tool if calling the other tools is unnecessary. The list of actions you want to call should be formatted as a list of json objects, for example:
```json
[
{
"tool_name": title of the tool in the specification,
"parameters": a dict of parameters to input into the tool as they are defined in the specs, or {} if it takes no parameters
}
]```<|END_OF_TURN_TOKEN|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/CohereForAI-c4ai-command-r7b-12-2024-tool_use.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: true
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|># System Preamble
You are in contextual safety mode. You will reject requests to generate child sexual abuse material and child exploitation material in your responses. You will accept to provide information and creative content related to violence, hate, misinformation or sex, but you will not provide any content that could directly or indirectly lead to harmful outcomes.
Your information cutoff date is June 2024.
You have been trained on data in English, French, Spanish, Italian, German, Portuguese, Japanese, Korean, Modern Standard Arabic, Mandarin, Russian, Indonesian, Turkish, Dutch, Polish, Persian, Vietnamese, Czech, Hindi, Ukrainian, Romanian, Greek and Hebrew but have the ability to speak many more languages.
'
Common Suffix: '# Default Preamble
The following instructions are your defaults unless specified elsewhere in developer preamble or user prompt.
- Your name is Command.
- You are a large language model built by Cohere.
- You reply conversationally with a friendly and informative tone and often include introductory statements and follow-up questions.
- If the input is ambiguous, ask clarifying follow-up questions.
- Use Markdown-specific formatting in your response (for example to highlight phrases in bold or italics, create tables, or format code blocks).
- Use LaTeX to generate mathematical notation for complex equations.
- When responding in English, use American English unless context indicates otherwise.
- When outputting responses of more than seven sentences, split the response into paragraphs.
- Prefer the active voice.
- Adhere to the APA style guidelines for punctuation, spelling, hyphenation, capitalization, numbers, lists, and quotation marks. Do not worry about them for other elements such as italics, citations, figures, or references.
- Use gender-neutral pronouns for unspecified persons.
- Limit lists to no more than 10 items unless the list is a set of finite instructions, in which case complete the list.
- Use the third person when asked to write a summary.
- When asked to extract values from source material, use the exact form, separated by commas.
- When generating code output, please provide an explanation after the code.
- When generating code output without specifying the programming language, please generate Python code.
- If you are asked a question that requires reasoning, first think through your answer, slowly and step by step, then answer.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, please help me.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>'
Left (difference): ''
Right (difference): '
You have been trained to have advanced reasoning and tool-use capabilities and you should make best use of these skills to serve user's requests.
## Tool Use
Think about how you can make best use of the provided tools to help with the task and come up with a high level plan that you will execute first.
0. Start by writing <|START_THINKING|> followed by a detailed step by step plan of how you will solve the problem. For each step explain your thinking fully and give details of required tool calls (if needed). Unless specified otherwise, you write your plan in natural language. When you finish, close it out with <|END_THINKING|>.
You can optionally choose to skip this step when the user request is so straightforward to address that only a trivial plan would be needed.
NOTE: You MUST skip this step when you are directly responding to the user's request without using any tools.
Then carry out your plan by repeatedly executing the following steps.
1. Action: write <|START_ACTION|> followed by a list of JSON-formatted tool calls, with each one containing "tool_name" and "parameters" fields.
When there are multiple tool calls which are completely independent of each other (i.e. they can be executed in parallel), you should list them out all together in one step. When you finish, close it out with <|END_ACTION|>.
2. Observation: you will then receive results of those tool calls in JSON format in the very next turn, wrapped around by <|START_TOOL_RESULT|> and <|END_TOOL_RESULT|>. Carefully observe those results and think about what to do next. Note that these results will be provided to you in a separate turn. NEVER hallucinate results.
Every tool call produces a list of results (when a tool call produces no result or a single result, it'll still get wrapped inside a list). Each result is clearly linked to its originating tool call via its "tool_call_id".
3. Reflection: start the next turn by writing <|START_THINKING|> followed by what you've figured out so far, any changes you need to make to your plan, and what you will do next. When you finish, close it out with <|END_THINKING|>.
You can optionally choose to skip this step when everything is going according to plan and no special pieces of information or reasoning chains need to be recorded.
NOTE: You MUST skip this step when you are done with tool-use actions and are ready to respond to the user.
You can repeat the above 3 steps multiple times (could be 0 times too if no suitable tool calls are available or needed), until you decide it's time to finally respond to the user.
4. Response: then break out of the loop and write <|START_RESPONSE|> followed by a piece of text which serves as a response to the user's last request. Use all previous tool calls and results to help you when formulating your response. When you finish, close it out with <|END_RESPONSE|>.
## Available Tools
Here is the list of tools that you have available to you.
You can ONLY use the tools listed here. When a tool is not listed below, it is NOT available and you should NEVER attempt to use it.
Each tool is represented as a JSON object with fields like "name", "description", "parameters" (per JSON Schema), and optionally, "responses" (per JSON Schema).
```json
[
{"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}, "responses": null}
]
```
'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|># System Preamble
You are in contextual safety mode. You will reject requests to generate child sexual abuse material and child exploitation material in your responses. You will accept to provide information and creative content related to violence, hate, misinformation or sex, but you will not provide any content that could directly or indirectly lead to harmful outcomes.
Your information cutoff date is June 2024.
You have been trained on data in English, French, Spanish, Italian, German, Portuguese, Japanese, Korean, Modern Standard Arabic, Mandarin, Russian, Indonesian, Turkish, Dutch, Polish, Persian, Vietnamese, Czech, Hindi, Ukrainian, Romanian, Greek and Hebrew but have the ability to speak many more languages.
# Default Preamble
The following instructions are your defaults unless specified elsewhere in developer preamble or user prompt.
- Your name is Command.
- You are a large language model built by Cohere.
- You reply conversationally with a friendly and informative tone and often include introductory statements and follow-up questions.
- If the input is ambiguous, ask clarifying follow-up questions.
- Use Markdown-specific formatting in your response (for example to highlight phrases in bold or italics, create tables, or format code blocks).
- Use LaTeX to generate mathematical notation for complex equations.
- When responding in English, use American English unless context indicates otherwise.
- When outputting responses of more than seven sentences, split the response into paragraphs.
- Prefer the active voice.
- Adhere to the APA style guidelines for punctuation, spelling, hyphenation, capitalization, numbers, lists, and quotation marks. Do not worry about them for other elements such as italics, citations, figures, or references.
- Use gender-neutral pronouns for unspecified persons.
- Limit lists to no more than 10 items unless the list is a set of finite instructions, in which case complete the list.
- Use the third person when asked to write a summary.
- When asked to extract values from source material, use the exact form, separated by commas.
- When generating code output, please provide an explanation after the code.
- When generating code output without specifying the programming language, please generate Python code.
- If you are asked a question that requires reasoning, first think through your answer, slowly and step by step, then answer.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, please help me.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|># System Preamble
You are in contextual safety mode. You will reject requests to generate child sexual abuse material and child exploitation material in your responses. You will accept to provide information and creative content related to violence, hate, misinformation or sex, but you will not provide any content that could directly or indirectly lead to harmful outcomes.
Your information cutoff date is June 2024.
You have been trained on data in English, French, Spanish, Italian, German, Portuguese, Japanese, Korean, Modern Standard Arabic, Mandarin, Russian, Indonesian, Turkish, Dutch, Polish, Persian, Vietnamese, Czech, Hindi, Ukrainian, Romanian, Greek and Hebrew but have the ability to speak many more languages.
# Default Preamble
The following instructions are your defaults unless specified elsewhere in developer preamble or user prompt.
- Your name is Command.
- You are a large language model built by Cohere.
- You reply conversationally with a friendly and informative tone and often include introductory statements and follow-up questions.
- If the input is ambiguous, ask clarifying follow-up questions.
- Use Markdown-specific formatting in your response (for example to highlight phrases in bold or italics, create tables, or format code blocks).
- Use LaTeX to generate mathematical notation for complex equations.
- When responding in English, use American English unless context indicates otherwise.
- When outputting responses of more than seven sentences, split the response into paragraphs.
- Prefer the active voice.
- Adhere to the APA style guidelines for punctuation, spelling, hyphenation, capitalization, numbers, lists, and quotation marks. Do not worry about them for other elements such as italics, citations, figures, or references.
- Use gender-neutral pronouns for unspecified persons.
- Limit lists to no more than 10 items unless the list is a set of finite instructions, in which case complete the list.
- Use the third person when asked to write a summary.
- When asked to extract values from source material, use the exact form, separated by commas.
- When generating code output, please provide an explanation after the code.
- When generating code output without specifying the programming language, please generate Python code.
- If you are asked a question that requires reasoning, first think through your answer, slowly and step by step, then answer.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, please help me.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|><|START_RESPONSE|>I can help you with that.<|END_RESPONSE|><|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|># System Preamble
You are in contextual safety mode. You will reject requests to generate child sexual abuse material and child exploitation material in your responses. You will accept to provide information and creative content related to violence, hate, misinformation or sex, but you will not provide any content that could directly or indirectly lead to harmful outcomes.
Your information cutoff date is June 2024.
You have been trained on data in English, French, Spanish, Italian, German, Portuguese, Japanese, Korean, Modern Standard Arabic, Mandarin, Russian, Indonesian, Turkish, Dutch, Polish, Persian, Vietnamese, Czech, Hindi, Ukrainian, Romanian, Greek and Hebrew but have the ability to speak many more languages.
# Default Preamble
The following instructions are your defaults unless specified elsewhere in developer preamble or user prompt.
- Your name is Command.
- You are a large language model built by Cohere.
- You reply conversationally with a friendly and informative tone and often include introductory statements and follow-up questions.
- If the input is ambiguous, ask clarifying follow-up questions.
- Use Markdown-specific formatting in your response (for example to highlight phrases in bold or italics, create tables, or format code blocks).
- Use LaTeX to generate mathematical notation for complex equations.
- When responding in English, use American English unless context indicates otherwise.
- When outputting responses of more than seven sentences, split the response into paragraphs.
- Prefer the active voice.
- Adhere to the APA style guidelines for punctuation, spelling, hyphenation, capitalization, numbers, lists, and quotation marks. Do not worry about them for other elements such as italics, citations, figures, or references.
- Use gender-neutral pronouns for unspecified persons.
- Limit lists to no more than 10 items unless the list is a set of finite instructions, in which case complete the list.
- Use the third person when asked to write a summary.
- When asked to extract values from source material, use the exact form, separated by commas.
- When generating code output, please provide an explanation after the code.
- When generating code output without specifying the programming language, please generate Python code.
- If you are asked a question that requires reasoning, first think through your answer, slowly and step by step, then answer.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, please help me.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|><|START_RESPONSE|>I can help you with that.<|END_RESPONSE|><|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Thank you.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|># System Preamble
You are in contextual safety mode. You will reject requests to generate child sexual abuse material and child exploitation material in your responses. You will accept to provide information and creative content related to violence, hate, misinformation or sex, but you will not provide any content that could directly or indirectly lead to harmful outcomes.
Your information cutoff date is June 2024.
You have been trained on data in English, French, Spanish, Italian, German, Portuguese, Japanese, Korean, Modern Standard Arabic, Mandarin, Russian, Indonesian, Turkish, Dutch, Polish, Persian, Vietnamese, Czech, Hindi, Ukrainian, Romanian, Greek and Hebrew but have the ability to speak many more languages.
You have been trained to have advanced reasoning and tool-use capabilities and you should make best use of these skills to serve user's requests.
## Tool Use
Think about how you can make best use of the provided tools to help with the task and come up with a high level plan that you will execute first.
0. Start by writing <|START_THINKING|> followed by a detailed step by step plan of how you will solve the problem. For each step explain your thinking fully and give details of required tool calls (if needed). Unless specified otherwise, you write your plan in natural language. When you finish, close it out with <|END_THINKING|>.
You can optionally choose to skip this step when the user request is so straightforward to address that only a trivial plan would be needed.
NOTE: You MUST skip this step when you are directly responding to the user's request without using any tools.
Then carry out your plan by repeatedly executing the following steps.
1. Action: write <|START_ACTION|> followed by a list of JSON-formatted tool calls, with each one containing "tool_name" and "parameters" fields.
When there are multiple tool calls which are completely independent of each other (i.e. they can be executed in parallel), you should list them out all together in one step. When you finish, close it out with <|END_ACTION|>.
2. Observation: you will then receive results of those tool calls in JSON format in the very next turn, wrapped around by <|START_TOOL_RESULT|> and <|END_TOOL_RESULT|>. Carefully observe those results and think about what to do next. Note that these results will be provided to you in a separate turn. NEVER hallucinate results.
Every tool call produces a list of results (when a tool call produces no result or a single result, it'll still get wrapped inside a list). Each result is clearly linked to its originating tool call via its "tool_call_id".
3. Reflection: start the next turn by writing <|START_THINKING|> followed by what you've figured out so far, any changes you need to make to your plan, and what you will do next. When you finish, close it out with <|END_THINKING|>.
You can optionally choose to skip this step when everything is going according to plan and no special pieces of information or reasoning chains need to be recorded.
NOTE: You MUST skip this step when you are done with tool-use actions and are ready to respond to the user.
You can repeat the above 3 steps multiple times (could be 0 times too if no suitable tool calls are available or needed), until you decide it's time to finally respond to the user.
4. Response: then break out of the loop and write <|START_RESPONSE|> followed by a piece of text which serves as a response to the user's last request. Use all previous tool calls and results to help you when formulating your response. When you finish, close it out with <|END_RESPONSE|>.
## Available Tools
Here is the list of tools that you have available to you.
You can ONLY use the tools listed here. When a tool is not listed below, it is NOT available and you should NEVER attempt to use it.
Each tool is represented as a JSON object with fields like "name", "description", "parameters" (per JSON Schema), and optionally, "responses" (per JSON Schema).
```json
[
{"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}, "responses": null}
]
```
# Default Preamble
The following instructions are your defaults unless specified elsewhere in developer preamble or user prompt.
- Your name is Command.
- You are a large language model built by Cohere.
- You reply conversationally with a friendly and informative tone and often include introductory statements and follow-up questions.
- If the input is ambiguous, ask clarifying follow-up questions.
- Use Markdown-specific formatting in your response (for example to highlight phrases in bold or italics, create tables, or format code blocks).
- Use LaTeX to generate mathematical notation for complex equations.
- When responding in English, use American English unless context indicates otherwise.
- When outputting responses of more than seven sentences, split the response into paragraphs.
- Prefer the active voice.
- Adhere to the APA style guidelines for punctuation, spelling, hyphenation, capitalization, numbers, lists, and quotation marks. Do not worry about them for other elements such as italics, citations, figures, or references.
- Use gender-neutral pronouns for unspecified persons.
- Limit lists to no more than 10 items unless the list is a set of finite instructions, in which case complete the list.
- Use the third person when asked to write a summary.
- When asked to extract values from source material, use the exact form, separated by commas.
- When generating code output, please provide an explanation after the code.
- When generating code output without specifying the programming language, please generate Python code.
- If you are asked a question that requires reasoning, first think through your answer, slowly and step by step, then answer.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, please help me.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>'
Common Suffix: '<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>'
Left (difference): '<|START_RESPONSE|>Let me help you.<|END_RESPONSE|>'
Right (difference): '<|START_THINKING|><|END_THINKING|><|START_ACTION|>[
{"tool_call_id": "0", "tool_name": "test_function_name", "parameters": {"param1": "value1", "param2": "value2"}}
]<|END_ACTION|>'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|># System Preamble
You are in contextual safety mode. You will reject requests to generate child sexual abuse material and child exploitation material in your responses. You will accept to provide information and creative content related to violence, hate, misinformation or sex, but you will not provide any content that could directly or indirectly lead to harmful outcomes.
Your information cutoff date is June 2024.
You have been trained on data in English, French, Spanish, Italian, German, Portuguese, Japanese, Korean, Modern Standard Arabic, Mandarin, Russian, Indonesian, Turkish, Dutch, Polish, Persian, Vietnamese, Czech, Hindi, Ukrainian, Romanian, Greek and Hebrew but have the ability to speak many more languages.
You have been trained to have advanced reasoning and tool-use capabilities and you should make best use of these skills to serve user's requests.
## Tool Use
Think about how you can make best use of the provided tools to help with the task and come up with a high level plan that you will execute first.
0. Start by writing <|START_THINKING|> followed by a detailed step by step plan of how you will solve the problem. For each step explain your thinking fully and give details of required tool calls (if needed). Unless specified otherwise, you write your plan in natural language. When you finish, close it out with <|END_THINKING|>.
You can optionally choose to skip this step when the user request is so straightforward to address that only a trivial plan would be needed.
NOTE: You MUST skip this step when you are directly responding to the user's request without using any tools.
Then carry out your plan by repeatedly executing the following steps.
1. Action: write <|START_ACTION|> followed by a list of JSON-formatted tool calls, with each one containing "tool_name" and "parameters" fields.
When there are multiple tool calls which are completely independent of each other (i.e. they can be executed in parallel), you should list them out all together in one step. When you finish, close it out with <|END_ACTION|>.
2. Observation: you will then receive results of those tool calls in JSON format in the very next turn, wrapped around by <|START_TOOL_RESULT|> and <|END_TOOL_RESULT|>. Carefully observe those results and think about what to do next. Note that these results will be provided to you in a separate turn. NEVER hallucinate results.
Every tool call produces a list of results (when a tool call produces no result or a single result, it'll still get wrapped inside a list). Each result is clearly linked to its originating tool call via its "tool_call_id".
3. Reflection: start the next turn by writing <|START_THINKING|> followed by what you've figured out so far, any changes you need to make to your plan, and what you will do next. When you finish, close it out with <|END_THINKING|>.
You can optionally choose to skip this step when everything is going according to plan and no special pieces of information or reasoning chains need to be recorded.
NOTE: You MUST skip this step when you are done with tool-use actions and are ready to respond to the user.
You can repeat the above 3 steps multiple times (could be 0 times too if no suitable tool calls are available or needed), until you decide it's time to finally respond to the user.
4. Response: then break out of the loop and write <|START_RESPONSE|> followed by a piece of text which serves as a response to the user's last request. Use all previous tool calls and results to help you when formulating your response. When you finish, close it out with <|END_RESPONSE|>.
## Available Tools
Here is the list of tools that you have available to you.
You can ONLY use the tools listed here. When a tool is not listed below, it is NOT available and you should NEVER attempt to use it.
Each tool is represented as a JSON object with fields like "name", "description", "parameters" (per JSON Schema), and optionally, "responses" (per JSON Schema).
```json
[
{"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}, "responses": null}
]
```
# Default Preamble
The following instructions are your defaults unless specified elsewhere in developer preamble or user prompt.
- Your name is Command.
- You are a large language model built by Cohere.
- You reply conversationally with a friendly and informative tone and often include introductory statements and follow-up questions.
- If the input is ambiguous, ask clarifying follow-up questions.
- Use Markdown-specific formatting in your response (for example to highlight phrases in bold or italics, create tables, or format code blocks).
- Use LaTeX to generate mathematical notation for complex equations.
- When responding in English, use American English unless context indicates otherwise.
- When outputting responses of more than seven sentences, split the response into paragraphs.
- Prefer the active voice.
- Adhere to the APA style guidelines for punctuation, spelling, hyphenation, capitalization, numbers, lists, and quotation marks. Do not worry about them for other elements such as italics, citations, figures, or references.
- Use gender-neutral pronouns for unspecified persons.
- Limit lists to no more than 10 items unless the list is a set of finite instructions, in which case complete the list.
- Use the third person when asked to write a summary.
- When asked to extract values from source material, use the exact form, separated by commas.
- When generating code output, please provide an explanation after the code.
- When generating code output without specifying the programming language, please generate Python code.
- If you are asked a question that requires reasoning, first think through your answer, slowly and step by step, then answer.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, please help me.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>'
Common Suffix: '<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Continue.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>'
Left (difference): '<|START_RESPONSE|>Let me help you.<|END_RESPONSE|>'
Right (difference): '<|START_THINKING|><|END_THINKING|><|START_ACTION|>[
{"tool_call_id": "0", "tool_name": "test_function_name", "parameters": {"param1": "value1", "param2": "value2"}}
]<|END_ACTION|>'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|># System Preamble
You are in contextual safety mode. You will reject requests to generate child sexual abuse material and child exploitation material in your responses. You will accept to provide information and creative content related to violence, hate, misinformation or sex, but you will not provide any content that could directly or indirectly lead to harmful outcomes.
Your information cutoff date is June 2024.
You have been trained on data in English, French, Spanish, Italian, German, Portuguese, Japanese, Korean, Modern Standard Arabic, Mandarin, Russian, Indonesian, Turkish, Dutch, Polish, Persian, Vietnamese, Czech, Hindi, Ukrainian, Romanian, Greek and Hebrew but have the ability to speak many more languages.
You have been trained to have advanced reasoning and tool-use capabilities and you should make best use of these skills to serve user's requests.
## Tool Use
Think about how you can make best use of the provided tools to help with the task and come up with a high level plan that you will execute first.
0. Start by writing <|START_THINKING|> followed by a detailed step by step plan of how you will solve the problem. For each step explain your thinking fully and give details of required tool calls (if needed). Unless specified otherwise, you write your plan in natural language. When you finish, close it out with <|END_THINKING|>.
You can optionally choose to skip this step when the user request is so straightforward to address that only a trivial plan would be needed.
NOTE: You MUST skip this step when you are directly responding to the user's request without using any tools.
Then carry out your plan by repeatedly executing the following steps.
1. Action: write <|START_ACTION|> followed by a list of JSON-formatted tool calls, with each one containing "tool_name" and "parameters" fields.
When there are multiple tool calls which are completely independent of each other (i.e. they can be executed in parallel), you should list them out all together in one step. When you finish, close it out with <|END_ACTION|>.
2. Observation: you will then receive results of those tool calls in JSON format in the very next turn, wrapped around by <|START_TOOL_RESULT|> and <|END_TOOL_RESULT|>. Carefully observe those results and think about what to do next. Note that these results will be provided to you in a separate turn. NEVER hallucinate results.
Every tool call produces a list of results (when a tool call produces no result or a single result, it'll still get wrapped inside a list). Each result is clearly linked to its originating tool call via its "tool_call_id".
3. Reflection: start the next turn by writing <|START_THINKING|> followed by what you've figured out so far, any changes you need to make to your plan, and what you will do next. When you finish, close it out with <|END_THINKING|>.
You can optionally choose to skip this step when everything is going according to plan and no special pieces of information or reasoning chains need to be recorded.
NOTE: You MUST skip this step when you are done with tool-use actions and are ready to respond to the user.
You can repeat the above 3 steps multiple times (could be 0 times too if no suitable tool calls are available or needed), until you decide it's time to finally respond to the user.
4. Response: then break out of the loop and write <|START_RESPONSE|> followed by a piece of text which serves as a response to the user's last request. Use all previous tool calls and results to help you when formulating your response. When you finish, close it out with <|END_RESPONSE|>.
## Available Tools
Here is the list of tools that you have available to you.
You can ONLY use the tools listed here. When a tool is not listed below, it is NOT available and you should NEVER attempt to use it.
Each tool is represented as a JSON object with fields like "name", "description", "parameters" (per JSON Schema), and optionally, "responses" (per JSON Schema).
```json
[
{"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}, "responses": null}
]
```
# Default Preamble
The following instructions are your defaults unless specified elsewhere in developer preamble or user prompt.
- Your name is Command.
- You are a large language model built by Cohere.
- You reply conversationally with a friendly and informative tone and often include introductory statements and follow-up questions.
- If the input is ambiguous, ask clarifying follow-up questions.
- Use Markdown-specific formatting in your response (for example to highlight phrases in bold or italics, create tables, or format code blocks).
- Use LaTeX to generate mathematical notation for complex equations.
- When responding in English, use American English unless context indicates otherwise.
- When outputting responses of more than seven sentences, split the response into paragraphs.
- Prefer the active voice.
- Adhere to the APA style guidelines for punctuation, spelling, hyphenation, capitalization, numbers, lists, and quotation marks. Do not worry about them for other elements such as italics, citations, figures, or references.
- Use gender-neutral pronouns for unspecified persons.
- Limit lists to no more than 10 items unless the list is a set of finite instructions, in which case complete the list.
- Use the third person when asked to write a summary.
- When asked to extract values from source material, use the exact form, separated by commas.
- When generating code output, please provide an explanation after the code.
- When generating code output without specifying the programming language, please generate Python code.
- If you are asked a question that requires reasoning, first think through your answer, slowly and step by step, then answer.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, please help me.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|><|START_THINKING|><|END_THINKING|><|START_ACTION|>[
{"tool_call_id": "0", "tool_name": "test_function_name", "parameters": {"param1": "value1", "param2": "value2"}}'
Common Suffix: '
]<|END_ACTION|><|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>'
Left (difference): ''
Right (difference): ',
{"tool_call_id": "1", "tool_name": "test_function_name", "parameters": {"param1": "value3", "param2": "value4"}}'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|># System Preamble
You are in contextual safety mode. You will reject requests to generate child sexual abuse material and child exploitation material in your responses. You will accept to provide information and creative content related to violence, hate, misinformation or sex, but you will not provide any content that could directly or indirectly lead to harmful outcomes.
Your information cutoff date is June 2024.
You have been trained on data in English, French, Spanish, Italian, German, Portuguese, Japanese, Korean, Modern Standard Arabic, Mandarin, Russian, Indonesian, Turkish, Dutch, Polish, Persian, Vietnamese, Czech, Hindi, Ukrainian, Romanian, Greek and Hebrew but have the ability to speak many more languages.
You have been trained to have advanced reasoning and tool-use capabilities and you should make best use of these skills to serve user's requests.
## Tool Use
Think about how you can make best use of the provided tools to help with the task and come up with a high level plan that you will execute first.
0. Start by writing <|START_THINKING|> followed by a detailed step by step plan of how you will solve the problem. For each step explain your thinking fully and give details of required tool calls (if needed). Unless specified otherwise, you write your plan in natural language. When you finish, close it out with <|END_THINKING|>.
You can optionally choose to skip this step when the user request is so straightforward to address that only a trivial plan would be needed.
NOTE: You MUST skip this step when you are directly responding to the user's request without using any tools.
Then carry out your plan by repeatedly executing the following steps.
1. Action: write <|START_ACTION|> followed by a list of JSON-formatted tool calls, with each one containing "tool_name" and "parameters" fields.
When there are multiple tool calls which are completely independent of each other (i.e. they can be executed in parallel), you should list them out all together in one step. When you finish, close it out with <|END_ACTION|>.
2. Observation: you will then receive results of those tool calls in JSON format in the very next turn, wrapped around by <|START_TOOL_RESULT|> and <|END_TOOL_RESULT|>. Carefully observe those results and think about what to do next. Note that these results will be provided to you in a separate turn. NEVER hallucinate results.
Every tool call produces a list of results (when a tool call produces no result or a single result, it'll still get wrapped inside a list). Each result is clearly linked to its originating tool call via its "tool_call_id".
3. Reflection: start the next turn by writing <|START_THINKING|> followed by what you've figured out so far, any changes you need to make to your plan, and what you will do next. When you finish, close it out with <|END_THINKING|>.
You can optionally choose to skip this step when everything is going according to plan and no special pieces of information or reasoning chains need to be recorded.
NOTE: You MUST skip this step when you are done with tool-use actions and are ready to respond to the user.
You can repeat the above 3 steps multiple times (could be 0 times too if no suitable tool calls are available or needed), until you decide it's time to finally respond to the user.
4. Response: then break out of the loop and write <|START_RESPONSE|> followed by a piece of text which serves as a response to the user's last request. Use all previous tool calls and results to help you when formulating your response. When you finish, close it out with <|END_RESPONSE|>.
## Available Tools
Here is the list of tools that you have available to you.
You can ONLY use the tools listed here. When a tool is not listed below, it is NOT available and you should NEVER attempt to use it.
Each tool is represented as a JSON object with fields like "name", "description", "parameters" (per JSON Schema), and optionally, "responses" (per JSON Schema).
```json
[
{"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}, "responses": null}
]
```
# Default Preamble
The following instructions are your defaults unless specified elsewhere in developer preamble or user prompt.
- Your name is Command.
- You are a large language model built by Cohere.
- You reply conversationally with a friendly and informative tone and often include introductory statements and follow-up questions.
- If the input is ambiguous, ask clarifying follow-up questions.
- Use Markdown-specific formatting in your response (for example to highlight phrases in bold or italics, create tables, or format code blocks).
- Use LaTeX to generate mathematical notation for complex equations.
- When responding in English, use American English unless context indicates otherwise.
- When outputting responses of more than seven sentences, split the response into paragraphs.
- Prefer the active voice.
- Adhere to the APA style guidelines for punctuation, spelling, hyphenation, capitalization, numbers, lists, and quotation marks. Do not worry about them for other elements such as italics, citations, figures, or references.
- Use gender-neutral pronouns for unspecified persons.
- Limit lists to no more than 10 items unless the list is a set of finite instructions, in which case complete the list.
- Use the third person when asked to write a summary.
- When asked to extract values from source material, use the exact form, separated by commas.
- When generating code output, please provide an explanation after the code.
- When generating code output without specifying the programming language, please generate Python code.
- If you are asked a question that requires reasoning, first think through your answer, slowly and step by step, then answer.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, please help me.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|><|START_THINKING|><|END_THINKING|><|START_ACTION|>[
{"tool_call_id": "0", "tool_name": "test_function_name", "parameters": {"param1": "value1", "param2": "value2"}}'
Common Suffix: '
]<|END_ACTION|><|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Continue.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>'
Left (difference): ''
Right (difference): ',
{"tool_call_id": "1", "tool_name": "test_function_name", "parameters": {"param1": "value3", "param2": "value4"}}'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|># System Preamble
You are in contextual safety mode. You will reject requests to generate child sexual abuse material and child exploitation material in your responses. You will accept to provide information and creative content related to violence, hate, misinformation or sex, but you will not provide any content that could directly or indirectly lead to harmful outcomes.
Your information cutoff date is June 2024.
You have been trained on data in English, French, Spanish, Italian, German, Portuguese, Japanese, Korean, Modern Standard Arabic, Mandarin, Russian, Indonesian, Turkish, Dutch, Polish, Persian, Vietnamese, Czech, Hindi, Ukrainian, Romanian, Greek and Hebrew but have the ability to speak many more languages.
You have been trained to have advanced reasoning and tool-use capabilities and you should make best use of these skills to serve user's requests.
## Tool Use
Think about how you can make best use of the provided tools to help with the task and come up with a high level plan that you will execute first.
0. Start by writing <|START_THINKING|> followed by a detailed step by step plan of how you will solve the problem. For each step explain your thinking fully and give details of required tool calls (if needed). Unless specified otherwise, you write your plan in natural language. When you finish, close it out with <|END_THINKING|>.
You can optionally choose to skip this step when the user request is so straightforward to address that only a trivial plan would be needed.
NOTE: You MUST skip this step when you are directly responding to the user's request without using any tools.
Then carry out your plan by repeatedly executing the following steps.
1. Action: write <|START_ACTION|> followed by a list of JSON-formatted tool calls, with each one containing "tool_name" and "parameters" fields.
When there are multiple tool calls which are completely independent of each other (i.e. they can be executed in parallel), you should list them out all together in one step. When you finish, close it out with <|END_ACTION|>.
2. Observation: you will then receive results of those tool calls in JSON format in the very next turn, wrapped around by <|START_TOOL_RESULT|> and <|END_TOOL_RESULT|>. Carefully observe those results and think about what to do next. Note that these results will be provided to you in a separate turn. NEVER hallucinate results.
Every tool call produces a list of results (when a tool call produces no result or a single result, it'll still get wrapped inside a list). Each result is clearly linked to its originating tool call via its "tool_call_id".
3. Reflection: start the next turn by writing <|START_THINKING|> followed by what you've figured out so far, any changes you need to make to your plan, and what you will do next. When you finish, close it out with <|END_THINKING|>.
You can optionally choose to skip this step when everything is going according to plan and no special pieces of information or reasoning chains need to be recorded.
NOTE: You MUST skip this step when you are done with tool-use actions and are ready to respond to the user.
You can repeat the above 3 steps multiple times (could be 0 times too if no suitable tool calls are available or needed), until you decide it's time to finally respond to the user.
4. Response: then break out of the loop and write <|START_RESPONSE|> followed by a piece of text which serves as a response to the user's last request. Use all previous tool calls and results to help you when formulating your response. When you finish, close it out with <|END_RESPONSE|>.
## Available Tools
Here is the list of tools that you have available to you.
You can ONLY use the tools listed here. When a tool is not listed below, it is NOT available and you should NEVER attempt to use it.
Each tool is represented as a JSON object with fields like "name", "description", "parameters" (per JSON Schema), and optionally, "responses" (per JSON Schema).
```json
[
{"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}, "responses": null}
]
```
# Default Preamble
The following instructions are your defaults unless specified elsewhere in developer preamble or user prompt.
- Your name is Command.
- You are a large language model built by Cohere.
- You reply conversationally with a friendly and informative tone and often include introductory statements and follow-up questions.
- If the input is ambiguous, ask clarifying follow-up questions.
- Use Markdown-specific formatting in your response (for example to highlight phrases in bold or italics, create tables, or format code blocks).
- Use LaTeX to generate mathematical notation for complex equations.
- When responding in English, use American English unless context indicates otherwise.
- When outputting responses of more than seven sentences, split the response into paragraphs.
- Prefer the active voice.
- Adhere to the APA style guidelines for punctuation, spelling, hyphenation, capitalization, numbers, lists, and quotation marks. Do not worry about them for other elements such as italics, citations, figures, or references.
- Use gender-neutral pronouns for unspecified persons.
- Limit lists to no more than 10 items unless the list is a set of finite instructions, in which case complete the list.
- Use the third person when asked to write a summary.
- When asked to extract values from source material, use the exact form, separated by commas.
- When generating code output, please provide an explanation after the code.
- When generating code output without specifying the programming language, please generate Python code.
- If you are asked a question that requires reasoning, first think through your answer, slowly and step by step, then answer.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hello, please help me.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|><|START_THINKING|><|END_THINKING|><|START_ACTION|>[
{"tool_call_id": "0", "tool_name": "test_function_name", "parameters": {"param1": "value1", "param2": "value2"}}
]<|END_ACTION|><|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/GLM-4.6.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '[gMASK]<sop>'
Common Suffix: '<|user|>
Hello, please help me.'
Left (difference): ''
Right (difference): '<|system|>
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, output the function name and arguments within the following XML format:
<tool_call>{function-name}
<arg_key>{arg-key-1}</arg_key>
<arg_value>{arg-value-1}</arg_value>
<arg_key>{arg-key-2}</arg_key>
<arg_value>{arg-value-2}</arg_value>
...
</tool_call>'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '[gMASK]<sop><|user|>
Hello, please help me.'
Common Suffix: ''
Left (difference): ''
Right (difference): '<|assistant|>'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '[gMASK]<sop><|user|>
Hello, please help me.<|assistant|>
<think>'
Common Suffix: '</think>
I can help you with that.'
Left (difference): ''
Right (difference): 'The user is asking for help. I should respond positively.'
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '[gMASK]<sop><|user|>
Hello, please help me.<|assistant|>
<think></think>
I can help you with that.<|user|>
Thank you.'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '[gMASK]<sop><|system|>
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, output the function name and arguments within the following XML format:
<tool_call>{function-name}
<arg_key>{arg-key-1}</arg_key>
<arg_value>{arg-value-1}</arg_value>
<arg_key>{arg-key-2}</arg_key>
<arg_value>{arg-value-2}</arg_value>
...
</tool_call><|user|>
Hello, please help me.<|assistant|>
<think></think>
'
Common Suffix: ''
Left (difference): 'Let me help you.'
Right (difference): '<tool_call>test_function_name
<arg_key>param1</arg_key>
<arg_value>value1</arg_value>
<arg_key>param2</arg_key>
<arg_value>value2</arg_value>
</tool_call>'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '[gMASK]<sop><|system|>
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, output the function name and arguments within the following XML format:
<tool_call>{function-name}
<arg_key>{arg-key-1}</arg_key>
<arg_value>{arg-value-1}</arg_value>
<arg_key>{arg-key-2}</arg_key>
<arg_value>{arg-value-2}</arg_value>
...
</tool_call><|user|>
Hello, please help me.<|assistant|>
<think></think>
'
Common Suffix: '<|user|>
Continue.'
Left (difference): 'Let me help you.'
Right (difference): '<tool_call>test_function_name
<arg_key>param1</arg_key>
<arg_value>value1</arg_value>
<arg_key>param2</arg_key>
<arg_value>value2</arg_value>
</tool_call>'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '[gMASK]<sop><|system|>
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, output the function name and arguments within the following XML format:
<tool_call>{function-name}
<arg_key>{arg-key-1}</arg_key>
<arg_value>{arg-value-1}</arg_value>
<arg_key>{arg-key-2}</arg_key>
<arg_value>{arg-value-2}</arg_value>
...
</tool_call><|user|>
Hello, please help me.<|assistant|>
<think></think>
<tool_call>test_function_name
<arg_key>param1</arg_key>
<arg_value>value1</arg_value>
<arg_key>param2</arg_key>
<arg_value>value2</arg_value>
</tool_call>'
Common Suffix: ''
Left (difference): ''
Right (difference): '
<tool_call>test_function_name
<arg_key>param1</arg_key>
<arg_value>value3</arg_value>
<arg_key>param2</arg_key>
<arg_value>value4</arg_value>
</tool_call>'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '[gMASK]<sop><|system|>
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, output the function name and arguments within the following XML format:
<tool_call>{function-name}
<arg_key>{arg-key-1}</arg_key>
<arg_value>{arg-value-1}</arg_value>
<arg_key>{arg-key-2}</arg_key>
<arg_value>{arg-value-2}</arg_value>
...
</tool_call><|user|>
Hello, please help me.<|assistant|>
<think></think>
<tool_call>test_function_name
<arg_key>param1</arg_key>
<arg_value>value1</arg_value>
<arg_key>param2</arg_key>
<arg_value>value2</arg_value>
</tool_call>'
Common Suffix: '<|user|>
Continue.'
Left (difference): ''
Right (difference): '
<tool_call>test_function_name
<arg_key>param1</arg_key>
<arg_value>value3</arg_value>
<arg_key>param2</arg_key>
<arg_value>value4</arg_value>
</tool_call>'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '[gMASK]<sop><|system|>
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, output the function name and arguments within the following XML format:
<tool_call>{function-name}
<arg_key>{arg-key-1}</arg_key>
<arg_value>{arg-value-1}</arg_value>
<arg_key>{arg-key-2}</arg_key>
<arg_value>{arg-value-2}</arg_value>
...
</tool_call><|user|>
Hello, please help me.<|assistant|>
<think>'
Common Suffix: '</think>
<tool_call>test_function_name
<arg_key>param1</arg_key>
<arg_value>value1</arg_value>
<arg_key>param2</arg_key>
<arg_value>value2</arg_value>
</tool_call>'
Left (difference): ''
Right (difference): 'I need to call the tool first.'
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/GLM-4.7-Flash.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '[gMASK]<sop>'
Common Suffix: '<|user|>Hello, please help me.'
Left (difference): ''
Right (difference): '<|system|>
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, output the function name and arguments within the following XML format:
<tool_call>{function-name}<arg_key>{arg-key-1}</arg_key><arg_value>{arg-value-1}</arg_value><arg_key>{arg-key-2}</arg_key><arg_value>{arg-value-2}</arg_value>...</tool_call>'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '[gMASK]<sop><|user|>Hello, please help me.'
Common Suffix: ''
Left (difference): ''
Right (difference): '<|assistant|><think>'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '[gMASK]<sop><|user|>Hello, please help me.<|assistant|>'
Common Suffix: '</think>I can help you with that.'
Left (difference): ''
Right (difference): '<think>The user is asking for help. I should respond positively.'
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '[gMASK]<sop><|user|>Hello, please help me.<|assistant|></think>I can help you with that.<|user|>Thank you.'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '[gMASK]<sop><|system|>
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, output the function name and arguments within the following XML format:
<tool_call>{function-name}<arg_key>{arg-key-1}</arg_key><arg_value>{arg-value-1}</arg_value><arg_key>{arg-key-2}</arg_key><arg_value>{arg-value-2}</arg_value>...</tool_call><|user|>Hello, please help me.<|assistant|></think>'
Common Suffix: ''
Left (difference): 'Let me help you.'
Right (difference): '<tool_call>test_function_name<arg_key>param1</arg_key><arg_value>value1</arg_value><arg_key>param2</arg_key><arg_value>value2</arg_value></tool_call>'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '[gMASK]<sop><|system|>
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, output the function name and arguments within the following XML format:
<tool_call>{function-name}<arg_key>{arg-key-1}</arg_key><arg_value>{arg-value-1}</arg_value><arg_key>{arg-key-2}</arg_key><arg_value>{arg-value-2}</arg_value>...</tool_call><|user|>Hello, please help me.<|assistant|></think>'
Common Suffix: '<|user|>Continue.'
Left (difference): 'Let me help you.'
Right (difference): '<tool_call>test_function_name<arg_key>param1</arg_key><arg_value>value1</arg_value><arg_key>param2</arg_key><arg_value>value2</arg_value></tool_call>'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '[gMASK]<sop><|system|>
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, output the function name and arguments within the following XML format:
<tool_call>{function-name}<arg_key>{arg-key-1}</arg_key><arg_value>{arg-value-1}</arg_value><arg_key>{arg-key-2}</arg_key><arg_value>{arg-value-2}</arg_value>...</tool_call><|user|>Hello, please help me.<|assistant|></think><tool_call>test_function_name<arg_key>param1</arg_key><arg_value>value1</arg_value><arg_key>param2</arg_key><arg_value>value2</arg_value></tool_call>'
Common Suffix: ''
Left (difference): ''
Right (difference): '<tool_call>test_function_name<arg_key>param1</arg_key><arg_value>value3</arg_value><arg_key>param2</arg_key><arg_value>value4</arg_value></tool_call>'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '[gMASK]<sop><|system|>
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, output the function name and arguments within the following XML format:
<tool_call>{function-name}<arg_key>{arg-key-1}</arg_key><arg_value>{arg-value-1}</arg_value><arg_key>{arg-key-2}</arg_key><arg_value>{arg-value-2}</arg_value>...</tool_call><|user|>Hello, please help me.<|assistant|></think><tool_call>test_function_name<arg_key>param1</arg_key><arg_value>value1</arg_value><arg_key>param2</arg_key><arg_value>value2</arg_value></tool_call>'
Common Suffix: '<|user|>Continue.'
Left (difference): ''
Right (difference): '<tool_call>test_function_name<arg_key>param1</arg_key><arg_value>value3</arg_value><arg_key>param2</arg_key><arg_value>value4</arg_value></tool_call>'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '[gMASK]<sop><|system|>
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, output the function name and arguments within the following XML format:
<tool_call>{function-name}<arg_key>{arg-key-1}</arg_key><arg_value>{arg-value-1}</arg_value><arg_key>{arg-key-2}</arg_key><arg_value>{arg-value-2}</arg_value>...</tool_call><|user|>Hello, please help me.<|assistant|>'
Common Suffix: '</think><tool_call>test_function_name<arg_key>param1</arg_key><arg_value>value1</arg_value><arg_key>param2</arg_key><arg_value>value2</arg_value></tool_call>'
Left (difference): ''
Right (difference): '<think>I need to call the tool first.'
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/Kimi-K2-Instruct.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<|im_system|>'
Common Suffix: 'system<|im_middle|>You are Kimi, an AI assistant created by Moonshot AI.<|im_end|>
<|im_user|>user<|im_middle|>Hello, please help me.<|im_end|>'
Left (difference): ''
Right (difference): 'tool_declare<|im_middle|>[{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}]<|im_end|><|im_system|>'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<|im_system|>system<|im_middle|>You are Kimi, an AI assistant created by Moonshot AI.<|im_end|>
<|im_user|>user<|im_middle|>Hello, please help me.<|im_end|>'
Common Suffix: ''
Left (difference): ''
Right (difference): '<|im_assistant|>assistant<|im_middle|>'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<|im_system|>system<|im_middle|>You are Kimi, an AI assistant created by Moonshot AI.<|im_end|>
<|im_user|>user<|im_middle|>Hello, please help me.<|im_end|><|im_assistant|>assistant<|im_middle|>I can help you with that.<|im_end|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<|im_system|>system<|im_middle|>You are Kimi, an AI assistant created by Moonshot AI.<|im_end|>
<|im_user|>user<|im_middle|>Hello, please help me.<|im_end|><|im_assistant|>assistant<|im_middle|>I can help you with that.<|im_end|><|im_user|>user<|im_middle|>Thank you.<|im_end|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<|im_system|>tool_declare<|im_middle|>[{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}]<|im_end|><|im_system|>system<|im_middle|>You are Kimi, an AI assistant created by Moonshot AI.<|im_end|>
<|im_user|>user<|im_middle|>Hello, please help me.<|im_end|><|im_assistant|>assistant<|im_middle|>'
Common Suffix: '<|im_end|>'
Left (difference): 'Let me help you.'
Right (difference): '<|tool_calls_section_begin|><|tool_call_begin|>functions.test_function_name:0<|tool_call_argument_begin|>{"param1": "value1", "param2": "value2"}<|tool_call_end|><|tool_calls_section_end|>'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<|im_system|>tool_declare<|im_middle|>[{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}]<|im_end|><|im_system|>system<|im_middle|>You are Kimi, an AI assistant created by Moonshot AI.<|im_end|>
<|im_user|>user<|im_middle|>Hello, please help me.<|im_end|><|im_assistant|>assistant<|im_middle|>'
Common Suffix: '<|im_end|><|im_user|>user<|im_middle|>Continue.<|im_end|>'
Left (difference): 'Let me help you.'
Right (difference): '<|tool_calls_section_begin|><|tool_call_begin|>functions.test_function_name:0<|tool_call_argument_begin|>{"param1": "value1", "param2": "value2"}<|tool_call_end|><|tool_calls_section_end|>'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '<|im_system|>tool_declare<|im_middle|>[{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}]<|im_end|><|im_system|>system<|im_middle|>You are Kimi, an AI assistant created by Moonshot AI.<|im_end|>
<|im_user|>user<|im_middle|>Hello, please help me.<|im_end|><|im_assistant|>assistant<|im_middle|><|tool_calls_section_begin|><|tool_call_begin|>functions.test_function_name:0<|tool_call_argument_begin|>{"param1": "value1", "param2": "value2"}<|tool_call_end|>'
Common Suffix: '<|tool_calls_section_end|><|im_end|>'
Left (difference): ''
Right (difference): '<|tool_call_begin|>functions.test_function_name:1<|tool_call_argument_begin|>{"param1": "value3", "param2": "value4"}<|tool_call_end|>'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '<|im_system|>tool_declare<|im_middle|>[{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}]<|im_end|><|im_system|>system<|im_middle|>You are Kimi, an AI assistant created by Moonshot AI.<|im_end|>
<|im_user|>user<|im_middle|>Hello, please help me.<|im_end|><|im_assistant|>assistant<|im_middle|><|tool_calls_section_begin|><|tool_call_begin|>functions.test_function_name:0<|tool_call_argument_begin|>{"param1": "value1", "param2": "value2"}<|tool_call_end|>'
Common Suffix: '<|tool_calls_section_end|><|im_end|><|im_user|>user<|im_middle|>Continue.<|im_end|>'
Left (difference): ''
Right (difference): '<|tool_call_begin|>functions.test_function_name:1<|tool_call_argument_begin|>{"param1": "value3", "param2": "value4"}<|tool_call_end|>'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '<|im_system|>tool_declare<|im_middle|>[{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}]<|im_end|><|im_system|>system<|im_middle|>You are Kimi, an AI assistant created by Moonshot AI.<|im_end|>
<|im_user|>user<|im_middle|>Hello, please help me.<|im_end|><|im_assistant|>assistant<|im_middle|><|tool_calls_section_begin|><|tool_call_begin|>functions.test_function_name:0<|tool_call_argument_begin|>{"param1": "value1", "param2": "value2"}<|tool_call_end|><|tool_calls_section_end|><|im_end|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/Kimi-K2-Thinking.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<|im_system|>'
Common Suffix: 'system<|im_middle|>You are Kimi, an AI assistant created by Moonshot AI.<|im_end|><|im_user|>user<|im_middle|>Hello, please help me.<|im_end|>'
Left (difference): ''
Right (difference): 'tool_declare<|im_middle|>[{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}]<|im_end|><|im_system|>'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<|im_system|>system<|im_middle|>You are Kimi, an AI assistant created by Moonshot AI.<|im_end|><|im_user|>user<|im_middle|>Hello, please help me.<|im_end|>'
Common Suffix: ''
Left (difference): ''
Right (difference): '<|im_assistant|>assistant<|im_middle|>'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<|im_system|>system<|im_middle|>You are Kimi, an AI assistant created by Moonshot AI.<|im_end|><|im_user|>user<|im_middle|>Hello, please help me.<|im_end|><|im_assistant|>assistant<|im_middle|><think></think>I can help you with that.<|im_end|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<|im_system|>system<|im_middle|>You are Kimi, an AI assistant created by Moonshot AI.<|im_end|><|im_user|>user<|im_middle|>Hello, please help me.<|im_end|><|im_assistant|>assistant<|im_middle|><think></think>I can help you with that.<|im_end|><|im_user|>user<|im_middle|>Thank you.<|im_end|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<|im_system|>tool_declare<|im_middle|>[{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}]<|im_end|><|im_system|>system<|im_middle|>You are Kimi, an AI assistant created by Moonshot AI.<|im_end|><|im_user|>user<|im_middle|>Hello, please help me.<|im_end|><|im_assistant|>assistant<|im_middle|><think></think>'
Common Suffix: '<|im_end|>'
Left (difference): 'Let me help you.'
Right (difference): '<|tool_calls_section_begin|><|tool_call_begin|>functions.test_function_name:0<|tool_call_argument_begin|>{"param1": "value1", "param2": "value2"}<|tool_call_end|><|tool_calls_section_end|>'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<|im_system|>tool_declare<|im_middle|>[{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}]<|im_end|><|im_system|>system<|im_middle|>You are Kimi, an AI assistant created by Moonshot AI.<|im_end|><|im_user|>user<|im_middle|>Hello, please help me.<|im_end|><|im_assistant|>assistant<|im_middle|><think></think>'
Common Suffix: '<|im_end|><|im_user|>user<|im_middle|>Continue.<|im_end|>'
Left (difference): 'Let me help you.'
Right (difference): '<|tool_calls_section_begin|><|tool_call_begin|>functions.test_function_name:0<|tool_call_argument_begin|>{"param1": "value1", "param2": "value2"}<|tool_call_end|><|tool_calls_section_end|>'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '<|im_system|>tool_declare<|im_middle|>[{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}]<|im_end|><|im_system|>system<|im_middle|>You are Kimi, an AI assistant created by Moonshot AI.<|im_end|><|im_user|>user<|im_middle|>Hello, please help me.<|im_end|><|im_assistant|>assistant<|im_middle|><think></think><|tool_calls_section_begin|><|tool_call_begin|>functions.test_function_name:0<|tool_call_argument_begin|>{"param1": "value1", "param2": "value2"}<|tool_call_end|>'
Common Suffix: '<|tool_calls_section_end|><|im_end|>'
Left (difference): ''
Right (difference): '<|tool_call_begin|>functions.test_function_name:1<|tool_call_argument_begin|>{"param1": "value3", "param2": "value4"}<|tool_call_end|>'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '<|im_system|>tool_declare<|im_middle|>[{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}]<|im_end|><|im_system|>system<|im_middle|>You are Kimi, an AI assistant created by Moonshot AI.<|im_end|><|im_user|>user<|im_middle|>Hello, please help me.<|im_end|><|im_assistant|>assistant<|im_middle|><think></think><|tool_calls_section_begin|><|tool_call_begin|>functions.test_function_name:0<|tool_call_argument_begin|>{"param1": "value1", "param2": "value2"}<|tool_call_end|>'
Common Suffix: '<|tool_calls_section_end|><|im_end|><|im_user|>user<|im_middle|>Continue.<|im_end|>'
Left (difference): ''
Right (difference): '<|tool_call_begin|>functions.test_function_name:1<|tool_call_argument_begin|>{"param1": "value3", "param2": "value4"}<|tool_call_end|>'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '<|im_system|>tool_declare<|im_middle|>[{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}]<|im_end|><|im_system|>system<|im_middle|>You are Kimi, an AI assistant created by Moonshot AI.<|im_end|><|im_user|>user<|im_middle|>Hello, please help me.<|im_end|><|im_assistant|>assistant<|im_middle|><think>'
Common Suffix: '</think><|tool_calls_section_begin|><|tool_call_begin|>functions.test_function_name:0<|tool_call_argument_begin|>{"param1": "value1", "param2": "value2"}<|tool_call_end|><|tool_calls_section_end|><|im_end|>'
Left (difference): ''
Right (difference): 'I need to call the tool first.'
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/MiMo-VL.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<|im_start|>system
You are MiMo, an AI assistant developed by Xiaomi.'
Common Suffix: '<|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
'
Left (difference): ''
Right (difference): '
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:
<tool_call>
{"name": <function-name>, "arguments": <args-json-object>}
</tool_call>'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<|im_start|>system
You are MiMo, an AI assistant developed by Xiaomi.<|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): '<|im_start|>assistant
'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<|im_start|>system
You are MiMo, an AI assistant developed by Xiaomi.<|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
I can help you with that.<|im_end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<|im_start|>system
You are MiMo, an AI assistant developed by Xiaomi.<|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
I can help you with that.<|im_end|>
<|im_start|>user
Thank you.<|im_end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<|im_start|>system
You are MiMo, an AI assistant developed by Xiaomi.
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:
<tool_call>
{"name": <function-name>, "arguments": <args-json-object>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
'
Common Suffix: '<|im_end|>
'
Left (difference): 'Let me help you.'
Right (difference): '<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}
</tool_call>'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<|im_start|>system
You are MiMo, an AI assistant developed by Xiaomi.
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:
<tool_call>
{"name": <function-name>, "arguments": <args-json-object>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
'
Common Suffix: '<|im_end|>
<|im_start|>user
Continue.<|im_end|>
'
Left (difference): 'Let me help you.'
Right (difference): '<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}
</tool_call>'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '<|im_start|>system
You are MiMo, an AI assistant developed by Xiaomi.
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:
<tool_call>
{"name": <function-name>, "arguments": <args-json-object>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}
</tool_call>'
Common Suffix: '<|im_end|>
'
Left (difference): ''
Right (difference): '
<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value3", "param2": "value4"}}
</tool_call>'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '<|im_start|>system
You are MiMo, an AI assistant developed by Xiaomi.
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:
<tool_call>
{"name": <function-name>, "arguments": <args-json-object>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}
</tool_call>'
Common Suffix: '<|im_end|>
<|im_start|>user
Continue.<|im_end|>
'
Left (difference): ''
Right (difference): '
<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value3", "param2": "value4"}}
</tool_call>'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '<|im_start|>system
You are MiMo, an AI assistant developed by Xiaomi.
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:
<tool_call>
{"name": <function-name>, "arguments": <args-json-object>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}
</tool_call><|im_end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/MiniMax-M2.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: ']~!b[]~b]system
You are a helpful assistant.'
Common Suffix: '[e~[
]~b]user
Hello, please help me.[e~[
'
Left (difference): ''
Right (difference): '
# Tools
You may call one or more tools to assist with the user query.
Here are the tools available in JSONSchema format:
<tools>
<tool>{"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}</tool>
</tools>
When making tool calls, use XML format to invoke tools and pass parameters:
<minimax:tool_call>
<invoke name="tool-name-1">
<parameter name="param-key-1">param-value-1</parameter>
<parameter name="param-key-2">param-value-2</parameter>
...
</invoke>
</minimax:tool_call>'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: ']~!b[]~b]system
You are a helpful assistant.[e~[
]~b]user
Hello, please help me.[e~[
'
Common Suffix: ''
Left (difference): ''
Right (difference): ']~b]ai
<think>
'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: ']~!b[]~b]system
You are a helpful assistant.[e~[
]~b]user
Hello, please help me.[e~[
]~b]ai
'
Common Suffix: 'I can help you with that.[e~[
'
Left (difference): ''
Right (difference): '<think>
The user is asking for help. I should respond positively.
</think>
'
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: ']~!b[]~b]system
You are a helpful assistant.[e~[
]~b]user
Hello, please help me.[e~[
]~b]ai
I can help you with that.[e~[
]~b]user
Thank you.[e~[
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: ']~!b[]~b]system
You are a helpful assistant.
# Tools
You may call one or more tools to assist with the user query.
Here are the tools available in JSONSchema format:
<tools>
<tool>{"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}</tool>
</tools>
When making tool calls, use XML format to invoke tools and pass parameters:
<minimax:tool_call>
<invoke name="tool-name-1">
<parameter name="param-key-1">param-value-1</parameter>
<parameter name="param-key-2">param-value-2</parameter>
...
</invoke>
</minimax:tool_call>[e~[
]~b]user
Hello, please help me.[e~[
]~b]ai
'
Common Suffix: '[e~[
'
Left (difference): 'Let me help you.'
Right (difference): '
<minimax:tool_call>
<invoke name="test_function_name">
<parameter name="param1">value1</parameter>
<parameter name="param2">value2</parameter>
</invoke>
</minimax:tool_call>'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: ']~!b[]~b]system
You are a helpful assistant.
# Tools
You may call one or more tools to assist with the user query.
Here are the tools available in JSONSchema format:
<tools>
<tool>{"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}</tool>
</tools>
When making tool calls, use XML format to invoke tools and pass parameters:
<minimax:tool_call>
<invoke name="tool-name-1">
<parameter name="param-key-1">param-value-1</parameter>
<parameter name="param-key-2">param-value-2</parameter>
...
</invoke>
</minimax:tool_call>[e~[
]~b]user
Hello, please help me.[e~[
]~b]ai
'
Common Suffix: '[e~[
]~b]user
Continue.[e~[
'
Left (difference): 'Let me help you.'
Right (difference): '
<minimax:tool_call>
<invoke name="test_function_name">
<parameter name="param1">value1</parameter>
<parameter name="param2">value2</parameter>
</invoke>
</minimax:tool_call>'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: ']~!b[]~b]system
You are a helpful assistant.
# Tools
You may call one or more tools to assist with the user query.
Here are the tools available in JSONSchema format:
<tools>
<tool>{"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}</tool>
</tools>
When making tool calls, use XML format to invoke tools and pass parameters:
<minimax:tool_call>
<invoke name="tool-name-1">
<parameter name="param-key-1">param-value-1</parameter>
<parameter name="param-key-2">param-value-2</parameter>
...
</invoke>
</minimax:tool_call>[e~[
]~b]user
Hello, please help me.[e~[
]~b]ai
<minimax:tool_call>
<invoke name="test_function_name">
<parameter name="param1">value1</parameter>
<parameter name="param2">value2</parameter>
</invoke>
'
Common Suffix: '</minimax:tool_call>[e~[
'
Left (difference): ''
Right (difference): '<invoke name="test_function_name">
<parameter name="param1">value3</parameter>
<parameter name="param2">value4</parameter>
</invoke>
'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: ']~!b[]~b]system
You are a helpful assistant.
# Tools
You may call one or more tools to assist with the user query.
Here are the tools available in JSONSchema format:
<tools>
<tool>{"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}</tool>
</tools>
When making tool calls, use XML format to invoke tools and pass parameters:
<minimax:tool_call>
<invoke name="tool-name-1">
<parameter name="param-key-1">param-value-1</parameter>
<parameter name="param-key-2">param-value-2</parameter>
...
</invoke>
</minimax:tool_call>[e~[
]~b]user
Hello, please help me.[e~[
]~b]ai
<minimax:tool_call>
<invoke name="test_function_name">
<parameter name="param1">value1</parameter>
<parameter name="param2">value2</parameter>
</invoke>
'
Common Suffix: '</minimax:tool_call>[e~[
]~b]user
Continue.[e~[
'
Left (difference): ''
Right (difference): '<invoke name="test_function_name">
<parameter name="param1">value3</parameter>
<parameter name="param2">value4</parameter>
</invoke>
'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: ']~!b[]~b]system
You are a helpful assistant.
# Tools
You may call one or more tools to assist with the user query.
Here are the tools available in JSONSchema format:
<tools>
<tool>{"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}</tool>
</tools>
When making tool calls, use XML format to invoke tools and pass parameters:
<minimax:tool_call>
<invoke name="tool-name-1">
<parameter name="param-key-1">param-value-1</parameter>
<parameter name="param-key-2">param-value-2</parameter>
...
</invoke>
</minimax:tool_call>[e~[
]~b]user
Hello, please help me.[e~[
]~b]ai
'
Common Suffix: '
<minimax:tool_call>
<invoke name="test_function_name">
<parameter name="param1">value1</parameter>
<parameter name="param2">value2</parameter>
</invoke>
</minimax:tool_call>[e~[
'
Left (difference): ''
Right (difference): '<think>
I need to call the tool first.
</think>
'
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/Mistral-Small-3.2-24B-Instruct-2506.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: false
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '[SYSTEM_PROMPT]You are Mistral Small 3, a Large Language Model (LLM) created by Mistral AI, a French startup headquartered in Paris.
Your knowledge base was last updated on 2023-10-01. The current date is 2026-01-26.
When you're not sure about some information or when the user's request requires up-to-date or specific data, you must use the available tools to fetch the information. Do not hesitate to use tools whenever they can provide a more accurate or complete response. If no relevant tools are available, then clearly state that you don't have the information and avoid making up anything.
If the user's question is not clear, ambiguous, or does not provide enough context for you to accurately answer the question, you do not try to answer it right away and you rather ask the user to clarify their request (e.g. "What are some good restaurants around me?" => "Where are you?" or "When is the next flight to Tokyo" => "Where do you travel from?").
You are always very attentive to dates, and when asked about information at specific dates, you discard information that is at another date.
You follow these instructions in all languages, and always respond to the user in the language they use or request.
Next sections describe the capabilities that you have.
# WEB BROWSING INSTRUCTIONS
You cannot perform any web search or access internet to open URLs, links etc. If it seems like the user is expecting you to do so, you clarify the situation and ask the user to copy paste the text directly in the chat.
# MULTI-MODAL INSTRUCTIONS
You have the ability to read images, but you cannot generate images. You also cannot transcribe audio files or videos.
You cannot read nor transcribe audio files or videos.
# TOOL CALLING INSTRUCTIONS
You may have access to tools that you can use to fetch information or perform actions. You must use these tools in the following situations:
1. When the request requires up-to-date information.
2. When the request requires specific data that you do not have in your knowledge base.
3. When the request involves actions that you cannot perform without tools.
Always prioritize using tools to provide the most accurate and helpful response. If tools are not available, inform the user that you cannot perform the requested action at the moment.[/SYSTEM_PROMPT][INST]Hello, please help me.[/INST]'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '[SYSTEM_PROMPT]You are Mistral Small 3, a Large Language Model (LLM) created by Mistral AI, a French startup headquartered in Paris.
Your knowledge base was last updated on 2023-10-01. The current date is 2026-01-26.
When you're not sure about some information or when the user's request requires up-to-date or specific data, you must use the available tools to fetch the information. Do not hesitate to use tools whenever they can provide a more accurate or complete response. If no relevant tools are available, then clearly state that you don't have the information and avoid making up anything.
If the user's question is not clear, ambiguous, or does not provide enough context for you to accurately answer the question, you do not try to answer it right away and you rather ask the user to clarify their request (e.g. "What are some good restaurants around me?" => "Where are you?" or "When is the next flight to Tokyo" => "Where do you travel from?").
You are always very attentive to dates, and when asked about information at specific dates, you discard information that is at another date.
You follow these instructions in all languages, and always respond to the user in the language they use or request.
Next sections describe the capabilities that you have.
# WEB BROWSING INSTRUCTIONS
You cannot perform any web search or access internet to open URLs, links etc. If it seems like the user is expecting you to do so, you clarify the situation and ask the user to copy paste the text directly in the chat.
# MULTI-MODAL INSTRUCTIONS
You have the ability to read images, but you cannot generate images. You also cannot transcribe audio files or videos.
You cannot read nor transcribe audio files or videos.
# TOOL CALLING INSTRUCTIONS
You may have access to tools that you can use to fetch information or perform actions. You must use these tools in the following situations:
1. When the request requires up-to-date information.
2. When the request requires specific data that you do not have in your knowledge base.
3. When the request involves actions that you cannot perform without tools.
Always prioritize using tools to provide the most accurate and helpful response. If tools are not available, inform the user that you cannot perform the requested action at the moment.[/SYSTEM_PROMPT][INST]Hello, please help me.[/INST]'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '[SYSTEM_PROMPT]You are Mistral Small 3, a Large Language Model (LLM) created by Mistral AI, a French startup headquartered in Paris.
Your knowledge base was last updated on 2023-10-01. The current date is 2026-01-26.
When you're not sure about some information or when the user's request requires up-to-date or specific data, you must use the available tools to fetch the information. Do not hesitate to use tools whenever they can provide a more accurate or complete response. If no relevant tools are available, then clearly state that you don't have the information and avoid making up anything.
If the user's question is not clear, ambiguous, or does not provide enough context for you to accurately answer the question, you do not try to answer it right away and you rather ask the user to clarify their request (e.g. "What are some good restaurants around me?" => "Where are you?" or "When is the next flight to Tokyo" => "Where do you travel from?").
You are always very attentive to dates, and when asked about information at specific dates, you discard information that is at another date.
You follow these instructions in all languages, and always respond to the user in the language they use or request.
Next sections describe the capabilities that you have.
# WEB BROWSING INSTRUCTIONS
You cannot perform any web search or access internet to open URLs, links etc. If it seems like the user is expecting you to do so, you clarify the situation and ask the user to copy paste the text directly in the chat.
# MULTI-MODAL INSTRUCTIONS
You have the ability to read images, but you cannot generate images. You also cannot transcribe audio files or videos.
You cannot read nor transcribe audio files or videos.
# TOOL CALLING INSTRUCTIONS
You may have access to tools that you can use to fetch information or perform actions. You must use these tools in the following situations:
1. When the request requires up-to-date information.
2. When the request requires specific data that you do not have in your knowledge base.
3. When the request involves actions that you cannot perform without tools.
Always prioritize using tools to provide the most accurate and helpful response. If tools are not available, inform the user that you cannot perform the requested action at the moment.[/SYSTEM_PROMPT][INST]Hello, please help me.[/INST]I can help you with that.'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '[SYSTEM_PROMPT]You are Mistral Small 3, a Large Language Model (LLM) created by Mistral AI, a French startup headquartered in Paris.
Your knowledge base was last updated on 2023-10-01. The current date is 2026-01-26.
When you're not sure about some information or when the user's request requires up-to-date or specific data, you must use the available tools to fetch the information. Do not hesitate to use tools whenever they can provide a more accurate or complete response. If no relevant tools are available, then clearly state that you don't have the information and avoid making up anything.
If the user's question is not clear, ambiguous, or does not provide enough context for you to accurately answer the question, you do not try to answer it right away and you rather ask the user to clarify their request (e.g. "What are some good restaurants around me?" => "Where are you?" or "When is the next flight to Tokyo" => "Where do you travel from?").
You are always very attentive to dates, and when asked about information at specific dates, you discard information that is at another date.
You follow these instructions in all languages, and always respond to the user in the language they use or request.
Next sections describe the capabilities that you have.
# WEB BROWSING INSTRUCTIONS
You cannot perform any web search or access internet to open URLs, links etc. If it seems like the user is expecting you to do so, you clarify the situation and ask the user to copy paste the text directly in the chat.
# MULTI-MODAL INSTRUCTIONS
You have the ability to read images, but you cannot generate images. You also cannot transcribe audio files or videos.
You cannot read nor transcribe audio files or videos.
# TOOL CALLING INSTRUCTIONS
You may have access to tools that you can use to fetch information or perform actions. You must use these tools in the following situations:
1. When the request requires up-to-date information.
2. When the request requires specific data that you do not have in your knowledge base.
3. When the request involves actions that you cannot perform without tools.
Always prioritize using tools to provide the most accurate and helpful response. If tools are not available, inform the user that you cannot perform the requested action at the moment.[/SYSTEM_PROMPT][INST]Hello, please help me.[/INST]I can help you with that.[INST]Thank you.[/INST]'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
Analysis failed:
------------
While executing CallExpression at line 91, column 40 in source:
...↵ {{- raise_exception("Tool call IDs should be alphanumeric s...
^
Error: Jinja Exception: Tool call IDs should be alphanumeric strings with length 9!
================================================================================
ANALYZING TEMPLATE: models/templates/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: true
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<|im_start|>system
'
Common Suffix: '<|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
'
Left (difference): ''
Right (difference): '# Tools
You have access to the following functions:
<tools>
<function>
<name>test_function_name</name>
<description>A test function for debugging</description>
<parameters>
<parameter>
<name>param1</name>
<type>string</type>
<description>First parameter</description>
</parameter>
<parameter>
<name>param2</name>
<type>string</type>
<description>Second parameter</description>
</parameter>
<required>["param1", "param2"]</required>
</parameters>
</function>
</tools>
If you choose to call a function ONLY reply in the following format with NO suffix:
<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:
- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags
- Required parameters MUST be specified
- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after
- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls
</IMPORTANT>'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<|im_start|>system
<|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): '<|im_start|>assistant
<think>
'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<|im_start|>system
<|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
<think>'
Common Suffix: 'I can help you with that.<|im_end|>
'
Left (difference): '</think>'
Right (difference): '
The user is asking for help. I should respond positively.
</think>
'
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<|im_start|>system
<|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
<think></think>'
Common Suffix: 'I can help you with that.<|im_end|>
<|im_start|>user
Thank you.<|im_end|>
'
Left (difference): ''
Right (difference): '
'
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<|im_start|>system
# Tools
You have access to the following functions:
<tools>
<function>
<name>test_function_name</name>
<description>A test function for debugging</description>
<parameters>
<parameter>
<name>param1</name>
<type>string</type>
<description>First parameter</description>
</parameter>
<parameter>
<name>param2</name>
<type>string</type>
<description>Second parameter</description>
</parameter>
<required>["param1", "param2"]</required>
</parameters>
</function>
</tools>
If you choose to call a function ONLY reply in the following format with NO suffix:
<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:
- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags
- Required parameters MUST be specified
- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after
- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls
</IMPORTANT><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
<think></think>'
Common Suffix: '<|im_end|>
'
Left (difference): 'Let me help you.'
Right (difference): '
<tool_call>
<function=test_function_name>
<parameter=param1>
value1
</parameter>
<parameter=param2>
value2
</parameter>
</function>
</tool_call>
'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<|im_start|>system
# Tools
You have access to the following functions:
<tools>
<function>
<name>test_function_name</name>
<description>A test function for debugging</description>
<parameters>
<parameter>
<name>param1</name>
<type>string</type>
<description>First parameter</description>
</parameter>
<parameter>
<name>param2</name>
<type>string</type>
<description>Second parameter</description>
</parameter>
<required>["param1", "param2"]</required>
</parameters>
</function>
</tools>
If you choose to call a function ONLY reply in the following format with NO suffix:
<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:
- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags
- Required parameters MUST be specified
- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after
- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls
</IMPORTANT><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
<think></think>'
Common Suffix: '<|im_end|>
<|im_start|>user
Continue.<|im_end|>
'
Left (difference): 'Let me help you.'
Right (difference): '
<tool_call>
<function=test_function_name>
<parameter=param1>
value1
</parameter>
<parameter=param2>
value2
</parameter>
</function>
</tool_call>
'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '<|im_start|>system
# Tools
You have access to the following functions:
<tools>
<function>
<name>test_function_name</name>
<description>A test function for debugging</description>
<parameters>
<parameter>
<name>param1</name>
<type>string</type>
<description>First parameter</description>
</parameter>
<parameter>
<name>param2</name>
<type>string</type>
<description>Second parameter</description>
</parameter>
<required>["param1", "param2"]</required>
</parameters>
</function>
</tools>
If you choose to call a function ONLY reply in the following format with NO suffix:
<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:
- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags
- Required parameters MUST be specified
- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after
- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls
</IMPORTANT><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
<think></think>
<tool_call>
<function=test_function_name>
<parameter=param1>
value1
</parameter>
<parameter=param2>
value2
</parameter>
</function>
</tool_call>
'
Common Suffix: '<|im_end|>
'
Left (difference): ''
Right (difference): '<tool_call>
<function=test_function_name>
<parameter=param1>
value3
</parameter>
<parameter=param2>
value4
</parameter>
</function>
</tool_call>
'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '<|im_start|>system
# Tools
You have access to the following functions:
<tools>
<function>
<name>test_function_name</name>
<description>A test function for debugging</description>
<parameters>
<parameter>
<name>param1</name>
<type>string</type>
<description>First parameter</description>
</parameter>
<parameter>
<name>param2</name>
<type>string</type>
<description>Second parameter</description>
</parameter>
<required>["param1", "param2"]</required>
</parameters>
</function>
</tools>
If you choose to call a function ONLY reply in the following format with NO suffix:
<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:
- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags
- Required parameters MUST be specified
- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after
- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls
</IMPORTANT><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
<think></think>
<tool_call>
<function=test_function_name>
<parameter=param1>
value1
</parameter>
<parameter=param2>
value2
</parameter>
</function>
</tool_call>
'
Common Suffix: '<|im_end|>
<|im_start|>user
Continue.<|im_end|>
'
Left (difference): ''
Right (difference): '<tool_call>
<function=test_function_name>
<parameter=param1>
value3
</parameter>
<parameter=param2>
value4
</parameter>
</function>
</tool_call>
'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '<|im_start|>system
# Tools
You have access to the following functions:
<tools>
<function>
<name>test_function_name</name>
<description>A test function for debugging</description>
<parameters>
<parameter>
<name>param1</name>
<type>string</type>
<description>First parameter</description>
</parameter>
<parameter>
<name>param2</name>
<type>string</type>
<description>Second parameter</description>
</parameter>
<required>["param1", "param2"]</required>
</parameters>
</function>
</tools>
If you choose to call a function ONLY reply in the following format with NO suffix:
<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:
- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags
- Required parameters MUST be specified
- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after
- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls
</IMPORTANT><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
<think>'
Common Suffix: '</think>
<tool_call>
<function=test_function_name>
<parameter=param1>
value1
</parameter>
<parameter=param2>
value2
</parameter>
</function>
</tool_call>
<|im_end|>
'
Left (difference): ''
Right (difference): '
I need to call the tool first.
'
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/NVIDIA-Nemotron-Nano-v2.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<SPECIAL_10>System
'
Common Suffix: '
<SPECIAL_11>User
Hello, please help me.
'
Left (difference): ''
Right (difference): 'You can use the following tools to assist the user if required:
<AVAILABLE_TOOLS>[{"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}]</AVAILABLE_TOOLS>
If you decide to call any tool(s), use the following format:
<TOOLCALL>[{{"name": "tool_name1", "arguments": "tool_args1"}}, {{"name": "tool_name2", "arguments": "tool_args2"}}]</TOOLCALL>
The user will execute tool-calls and return responses from tool(s) in this format:
<TOOL_RESPONSE>[{{"tool_response1"}}, {{"tool_response2"}}]</TOOL_RESPONSE>
Based on the tool responses, you can call additional tools if needed, correct tool calls if any errors are found, or just respond to the user.'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<SPECIAL_10>System
<SPECIAL_11>User
Hello, please help me.
'
Common Suffix: ''
Left (difference): ''
Right (difference): '<SPECIAL_11>Assistant
<think>
'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<SPECIAL_10>System
<SPECIAL_11>User
Hello, please help me.
<SPECIAL_11>Assistant
<think>
I can help you with that.
<SPECIAL_12>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<SPECIAL_10>System
<SPECIAL_11>User
Hello, please help me.
<SPECIAL_11>Assistant
I can help you with that.
<SPECIAL_12>
<SPECIAL_11>User
Thank you.
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<SPECIAL_10>System
You can use the following tools to assist the user if required:
<AVAILABLE_TOOLS>[{"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}]</AVAILABLE_TOOLS>
If you decide to call any tool(s), use the following format:
<TOOLCALL>[{{"name": "tool_name1", "arguments": "tool_args1"}}, {{"name": "tool_name2", "arguments": "tool_args2"}}]</TOOLCALL>
The user will execute tool-calls and return responses from tool(s) in this format:
<TOOL_RESPONSE>[{{"tool_response1"}}, {{"tool_response2"}}]</TOOL_RESPONSE>
Based on the tool responses, you can call additional tools if needed, correct tool calls if any errors are found, or just respond to the user.
<SPECIAL_11>User
Hello, please help me.
<SPECIAL_11>Assistant
'
Common Suffix: '
'
Left (difference): '<think>
Let me help you.
<SPECIAL_12>'
Right (difference): '<TOOLCALL>[{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}]</TOOLCALL><SPECIAL_12>
'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<SPECIAL_10>System
You can use the following tools to assist the user if required:
<AVAILABLE_TOOLS>[{"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}]</AVAILABLE_TOOLS>
If you decide to call any tool(s), use the following format:
<TOOLCALL>[{{"name": "tool_name1", "arguments": "tool_args1"}}, {{"name": "tool_name2", "arguments": "tool_args2"}}]</TOOLCALL>
The user will execute tool-calls and return responses from tool(s) in this format:
<TOOL_RESPONSE>[{{"tool_response1"}}, {{"tool_response2"}}]</TOOL_RESPONSE>
Based on the tool responses, you can call additional tools if needed, correct tool calls if any errors are found, or just respond to the user.
<SPECIAL_11>User
Hello, please help me.
<SPECIAL_11>Assistant
'
Common Suffix: '
<SPECIAL_12>
<SPECIAL_11>User
Continue.
'
Left (difference): 'Let me help you.'
Right (difference): '<TOOLCALL>[{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}]</TOOLCALL>'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '<SPECIAL_10>System
You can use the following tools to assist the user if required:
<AVAILABLE_TOOLS>[{"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}]</AVAILABLE_TOOLS>
If you decide to call any tool(s), use the following format:
<TOOLCALL>[{{"name": "tool_name1", "arguments": "tool_args1"}}, {{"name": "tool_name2", "arguments": "tool_args2"}}]</TOOLCALL>
The user will execute tool-calls and return responses from tool(s) in this format:
<TOOL_RESPONSE>[{{"tool_response1"}}, {{"tool_response2"}}]</TOOL_RESPONSE>
Based on the tool responses, you can call additional tools if needed, correct tool calls if any errors are found, or just respond to the user.
<SPECIAL_11>User
Hello, please help me.
<SPECIAL_11>Assistant
<TOOLCALL>[{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}'
Common Suffix: ']</TOOLCALL><SPECIAL_12>
'
Left (difference): ''
Right (difference): ', {"name": "test_function_name", "arguments": {"param1": "value3", "param2": "value4"}}'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '<SPECIAL_10>System
You can use the following tools to assist the user if required:
<AVAILABLE_TOOLS>[{"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}]</AVAILABLE_TOOLS>
If you decide to call any tool(s), use the following format:
<TOOLCALL>[{{"name": "tool_name1", "arguments": "tool_args1"}}, {{"name": "tool_name2", "arguments": "tool_args2"}}]</TOOLCALL>
The user will execute tool-calls and return responses from tool(s) in this format:
<TOOL_RESPONSE>[{{"tool_response1"}}, {{"tool_response2"}}]</TOOL_RESPONSE>
Based on the tool responses, you can call additional tools if needed, correct tool calls if any errors are found, or just respond to the user.
<SPECIAL_11>User
Hello, please help me.
<SPECIAL_11>Assistant
<TOOLCALL>[{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}'
Common Suffix: ']</TOOLCALL>
<SPECIAL_12>
<SPECIAL_11>User
Continue.
'
Left (difference): ''
Right (difference): ', {"name": "test_function_name", "arguments": {"param1": "value3", "param2": "value4"}}'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '<SPECIAL_10>System
You can use the following tools to assist the user if required:
<AVAILABLE_TOOLS>[{"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}]</AVAILABLE_TOOLS>
If you decide to call any tool(s), use the following format:
<TOOLCALL>[{{"name": "tool_name1", "arguments": "tool_args1"}}, {{"name": "tool_name2", "arguments": "tool_args2"}}]</TOOLCALL>
The user will execute tool-calls and return responses from tool(s) in this format:
<TOOL_RESPONSE>[{{"tool_response1"}}, {{"tool_response2"}}]</TOOL_RESPONSE>
Based on the tool responses, you can call additional tools if needed, correct tool calls if any errors are found, or just respond to the user.
<SPECIAL_11>User
Hello, please help me.
<SPECIAL_11>Assistant
<TOOLCALL>[{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}]</TOOLCALL><SPECIAL_12>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/NousResearch-Hermes-2-Pro-Llama-3-8B-tool_use.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: true
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<|im_start|>system
You are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools: <tools> '
Common Suffix: ' </tools>Use the following pydantic model json schema for each tool call you will make: {"properties": {"name": {"title": "Name", "type": "string"}, "arguments": {"title": "Arguments", "type": "object"}}, "required": ["name", "arguments"], "title": "FunctionCall", "type": "object"}}
For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
<tool_call>
{"name": <function-name>, "arguments": <args-dict>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
'
Left (difference): ''
Right (difference): '{"type": "function", "function": {"name": "test_function_name", "description": "test_function_name(param1: str, param2: str) - A test function for debugging
Args:
param1(str): First parameter param2(str): Second parameter", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<|im_start|>system
You are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools: <tools> </tools>Use the following pydantic model json schema for each tool call you will make: {"properties": {"name": {"title": "Name", "type": "string"}, "arguments": {"title": "Arguments", "type": "object"}}, "required": ["name", "arguments"], "title": "FunctionCall", "type": "object"}}
For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
<tool_call>
{"name": <function-name>, "arguments": <args-dict>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): '<|im_start|>assistant
'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<|im_start|>system
You are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools: <tools> </tools>Use the following pydantic model json schema for each tool call you will make: {"properties": {"name": {"title": "Name", "type": "string"}, "arguments": {"title": "Arguments", "type": "object"}}, "required": ["name", "arguments"], "title": "FunctionCall", "type": "object"}}
For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
<tool_call>
{"name": <function-name>, "arguments": <args-dict>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
I can help you with that.<|im_end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<|im_start|>system
You are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools: <tools> </tools>Use the following pydantic model json schema for each tool call you will make: {"properties": {"name": {"title": "Name", "type": "string"}, "arguments": {"title": "Arguments", "type": "object"}}, "required": ["name", "arguments"], "title": "FunctionCall", "type": "object"}}
For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
<tool_call>
{"name": <function-name>, "arguments": <args-dict>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
I can help you with that.<|im_end|>
<|im_start|>user
Thank you.<|im_end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<|im_start|>system
You are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools: <tools> {"type": "function", "function": {"name": "test_function_name", "description": "test_function_name(param1: str, param2: str) - A test function for debugging
Args:
param1(str): First parameter param2(str): Second parameter", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}} </tools>Use the following pydantic model json schema for each tool call you will make: {"properties": {"name": {"title": "Name", "type": "string"}, "arguments": {"title": "Arguments", "type": "object"}}, "required": ["name", "arguments"], "title": "FunctionCall", "type": "object"}}
For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
<tool_call>
{"name": <function-name>, "arguments": <args-dict>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
'
Common Suffix: '<|im_end|>
'
Left (difference): 'Let me help you.'
Right (difference): '<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}
</tool_call>'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<|im_start|>system
You are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools: <tools> {"type": "function", "function": {"name": "test_function_name", "description": "test_function_name(param1: str, param2: str) - A test function for debugging
Args:
param1(str): First parameter param2(str): Second parameter", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}} </tools>Use the following pydantic model json schema for each tool call you will make: {"properties": {"name": {"title": "Name", "type": "string"}, "arguments": {"title": "Arguments", "type": "object"}}, "required": ["name", "arguments"], "title": "FunctionCall", "type": "object"}}
For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
<tool_call>
{"name": <function-name>, "arguments": <args-dict>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
'
Common Suffix: '<|im_end|>
<|im_start|>user
Continue.<|im_end|>
'
Left (difference): 'Let me help you.'
Right (difference): '<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}
</tool_call>'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '<|im_start|>system
You are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools: <tools> {"type": "function", "function": {"name": "test_function_name", "description": "test_function_name(param1: str, param2: str) - A test function for debugging
Args:
param1(str): First parameter param2(str): Second parameter", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}} </tools>Use the following pydantic model json schema for each tool call you will make: {"properties": {"name": {"title": "Name", "type": "string"}, "arguments": {"title": "Arguments", "type": "object"}}, "required": ["name", "arguments"], "title": "FunctionCall", "type": "object"}}
For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
<tool_call>
{"name": <function-name>, "arguments": <args-dict>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}
</tool_call>'
Common Suffix: '<|im_end|>
'
Left (difference): ''
Right (difference): '
<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value3", "param2": "value4"}}
</tool_call>'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '<|im_start|>system
You are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools: <tools> {"type": "function", "function": {"name": "test_function_name", "description": "test_function_name(param1: str, param2: str) - A test function for debugging
Args:
param1(str): First parameter param2(str): Second parameter", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}} </tools>Use the following pydantic model json schema for each tool call you will make: {"properties": {"name": {"title": "Name", "type": "string"}, "arguments": {"title": "Arguments", "type": "object"}}, "required": ["name", "arguments"], "title": "FunctionCall", "type": "object"}}
For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
<tool_call>
{"name": <function-name>, "arguments": <args-dict>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}
</tool_call>'
Common Suffix: '<|im_end|>
<|im_start|>user
Continue.<|im_end|>
'
Left (difference): ''
Right (difference): '
<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value3", "param2": "value4"}}
</tool_call>'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '<|im_start|>system
You are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools: <tools> {"type": "function", "function": {"name": "test_function_name", "description": "test_function_name(param1: str, param2: str) - A test function for debugging
Args:
param1(str): First parameter param2(str): Second parameter", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}} </tools>Use the following pydantic model json schema for each tool call you will make: {"properties": {"name": {"title": "Name", "type": "string"}, "arguments": {"title": "Arguments", "type": "object"}}, "required": ["name", "arguments"], "title": "FunctionCall", "type": "object"}}
For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
<tool_call>
{"name": <function-name>, "arguments": <args-dict>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}
</tool_call><|im_end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/NousResearch-Hermes-3-Llama-3.1-8B-tool_use.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: true
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<|im_start|>system
You are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools: <tools> '
Common Suffix: ' </tools>Use the following pydantic model json schema for each tool call you will make: {"properties": {"name": {"title": "Name", "type": "string"}, "arguments": {"title": "Arguments", "type": "object"}}, "required": ["name", "arguments"], "title": "FunctionCall", "type": "object"}}
For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
<tool_call>
{"name": <function-name>, "arguments": <args-dict>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
'
Left (difference): ''
Right (difference): '{"type": "function", "function": {"name": "test_function_name", "description": "test_function_name(param1: str, param2: str) - A test function for debugging
Args:
param1(str): First parameter param2(str): Second parameter", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<|im_start|>system
You are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools: <tools> </tools>Use the following pydantic model json schema for each tool call you will make: {"properties": {"name": {"title": "Name", "type": "string"}, "arguments": {"title": "Arguments", "type": "object"}}, "required": ["name", "arguments"], "title": "FunctionCall", "type": "object"}}
For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
<tool_call>
{"name": <function-name>, "arguments": <args-dict>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): '<|im_start|>assistant
'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<|im_start|>system
You are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools: <tools> </tools>Use the following pydantic model json schema for each tool call you will make: {"properties": {"name": {"title": "Name", "type": "string"}, "arguments": {"title": "Arguments", "type": "object"}}, "required": ["name", "arguments"], "title": "FunctionCall", "type": "object"}}
For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
<tool_call>
{"name": <function-name>, "arguments": <args-dict>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
I can help you with that.<|im_end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<|im_start|>system
You are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools: <tools> </tools>Use the following pydantic model json schema for each tool call you will make: {"properties": {"name": {"title": "Name", "type": "string"}, "arguments": {"title": "Arguments", "type": "object"}}, "required": ["name", "arguments"], "title": "FunctionCall", "type": "object"}}
For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
<tool_call>
{"name": <function-name>, "arguments": <args-dict>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
I can help you with that.<|im_end|>
<|im_start|>user
Thank you.<|im_end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<|im_start|>system
You are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools: <tools> {"type": "function", "function": {"name": "test_function_name", "description": "test_function_name(param1: str, param2: str) - A test function for debugging
Args:
param1(str): First parameter param2(str): Second parameter", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}} </tools>Use the following pydantic model json schema for each tool call you will make: {"properties": {"name": {"title": "Name", "type": "string"}, "arguments": {"title": "Arguments", "type": "object"}}, "required": ["name", "arguments"], "title": "FunctionCall", "type": "object"}}
For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
<tool_call>
{"name": <function-name>, "arguments": <args-dict>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
'
Common Suffix: '<|im_end|>
'
Left (difference): 'Let me help you.'
Right (difference): '<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}
</tool_call>'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<|im_start|>system
You are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools: <tools> {"type": "function", "function": {"name": "test_function_name", "description": "test_function_name(param1: str, param2: str) - A test function for debugging
Args:
param1(str): First parameter param2(str): Second parameter", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}} </tools>Use the following pydantic model json schema for each tool call you will make: {"properties": {"name": {"title": "Name", "type": "string"}, "arguments": {"title": "Arguments", "type": "object"}}, "required": ["name", "arguments"], "title": "FunctionCall", "type": "object"}}
For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
<tool_call>
{"name": <function-name>, "arguments": <args-dict>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
'
Common Suffix: '<|im_end|>
<|im_start|>user
Continue.<|im_end|>
'
Left (difference): 'Let me help you.'
Right (difference): '<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}
</tool_call>'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '<|im_start|>system
You are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools: <tools> {"type": "function", "function": {"name": "test_function_name", "description": "test_function_name(param1: str, param2: str) - A test function for debugging
Args:
param1(str): First parameter param2(str): Second parameter", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}} </tools>Use the following pydantic model json schema for each tool call you will make: {"properties": {"name": {"title": "Name", "type": "string"}, "arguments": {"title": "Arguments", "type": "object"}}, "required": ["name", "arguments"], "title": "FunctionCall", "type": "object"}}
For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
<tool_call>
{"name": <function-name>, "arguments": <args-dict>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}
</tool_call>'
Common Suffix: '<|im_end|>
'
Left (difference): ''
Right (difference): '
<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value3", "param2": "value4"}}
</tool_call>'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '<|im_start|>system
You are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools: <tools> {"type": "function", "function": {"name": "test_function_name", "description": "test_function_name(param1: str, param2: str) - A test function for debugging
Args:
param1(str): First parameter param2(str): Second parameter", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}} </tools>Use the following pydantic model json schema for each tool call you will make: {"properties": {"name": {"title": "Name", "type": "string"}, "arguments": {"title": "Arguments", "type": "object"}}, "required": ["name", "arguments"], "title": "FunctionCall", "type": "object"}}
For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
<tool_call>
{"name": <function-name>, "arguments": <args-dict>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}
</tool_call>'
Common Suffix: '<|im_end|>
<|im_start|>user
Continue.<|im_end|>
'
Left (difference): ''
Right (difference): '
<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value3", "param2": "value4"}}
</tool_call>'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '<|im_start|>system
You are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools: <tools> {"type": "function", "function": {"name": "test_function_name", "description": "test_function_name(param1: str, param2: str) - A test function for debugging
Args:
param1(str): First parameter param2(str): Second parameter", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}} </tools>Use the following pydantic model json schema for each tool call you will make: {"properties": {"name": {"title": "Name", "type": "string"}, "arguments": {"title": "Arguments", "type": "object"}}, "required": ["name", "arguments"], "title": "FunctionCall", "type": "object"}}
For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
<tool_call>
{"name": <function-name>, "arguments": <args-dict>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}
</tool_call><|im_end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/Qwen-QwQ-32B.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<|im_start|>'
Common Suffix: 'user
Hello, please help me.<|im_end|>
'
Left (difference): ''
Right (difference): 'system
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:
<tool_call>
{"name": <function-name>, "arguments": <args-json-object>}
</tool_call><|im_end|>
<|im_start|>'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<|im_start|>user
Hello, please help me.<|im_end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): '<|im_start|>assistant
<think>
'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
I can help you with that.<|im_end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
I can help you with that.<|im_end|>
<|im_start|>user
Thank you.<|im_end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<|im_start|>system
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:
<tool_call>
{"name": <function-name>, "arguments": <args-json-object>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
'
Common Suffix: '<|im_end|>
'
Left (difference): 'Let me help you.'
Right (difference): '<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}
</tool_call>'
Analysis failed:
------------
While executing CallExpression at line 31, column 52 in source:
... {%- set content = message.content.split('</think>')[-1].lstrip('\n') %}↵ ...
^
Error: Callee is not a function: got Undefined (hint: 'split')
================================================================================
ANALYZING TEMPLATE: models/templates/Qwen-Qwen2.5-7B-Instruct.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<|im_start|>system
You are Qwen, created by Alibaba Cloud. You are a helpful assistant.'
Common Suffix: '<|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
'
Left (difference): ''
Right (difference): '
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:
<tool_call>
{"name": <function-name>, "arguments": <args-json-object>}
</tool_call>'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<|im_start|>system
You are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): '<|im_start|>assistant
'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<|im_start|>system
You are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
I can help you with that.<|im_end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<|im_start|>system
You are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
I can help you with that.<|im_end|>
<|im_start|>user
Thank you.<|im_end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<|im_start|>system
You are Qwen, created by Alibaba Cloud. You are a helpful assistant.
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:
<tool_call>
{"name": <function-name>, "arguments": <args-json-object>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
'
Common Suffix: '<|im_end|>
'
Left (difference): 'Let me help you.'
Right (difference): '<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}
</tool_call>'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<|im_start|>system
You are Qwen, created by Alibaba Cloud. You are a helpful assistant.
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:
<tool_call>
{"name": <function-name>, "arguments": <args-json-object>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
'
Common Suffix: '<|im_end|>
<|im_start|>user
Continue.<|im_end|>
'
Left (difference): 'Let me help you.'
Right (difference): '<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}
</tool_call>'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '<|im_start|>system
You are Qwen, created by Alibaba Cloud. You are a helpful assistant.
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:
<tool_call>
{"name": <function-name>, "arguments": <args-json-object>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}
</tool_call>'
Common Suffix: '<|im_end|>
'
Left (difference): ''
Right (difference): '
<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value3", "param2": "value4"}}
</tool_call>'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '<|im_start|>system
You are Qwen, created by Alibaba Cloud. You are a helpful assistant.
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:
<tool_call>
{"name": <function-name>, "arguments": <args-json-object>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}
</tool_call>'
Common Suffix: '<|im_end|>
<|im_start|>user
Continue.<|im_end|>
'
Left (difference): ''
Right (difference): '
<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value3", "param2": "value4"}}
</tool_call>'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '<|im_start|>system
You are Qwen, created by Alibaba Cloud. You are a helpful assistant.
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</tools>
For each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:
<tool_call>
{"name": <function-name>, "arguments": <args-json-object>}
</tool_call><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
<tool_call>
{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}
</tool_call><|im_end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/Qwen3-Coder.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: true
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<|im_start|>'
Common Suffix: 'user
Hello, please help me.<|im_end|>
'
Left (difference): ''
Right (difference): 'system
You are Qwen, a helpful AI assistant that can interact with a computer to solve tasks.
# Tools
You have access to the following tools:
<tools>
<function>
<name>test_function_name</name>
<description>A test function for debugging</description>
<parameters>
<parameter>
<name>param1</name>
<type>string</type>
<description>First parameter</description>
</parameter>
<parameter>
<name>param2</name>
<type>string</type>
<description>Second parameter</description>
</parameter>
<required>["param1", "param2"]</required>
</parameters>
</function>
</tools>
If you choose to call a tool ONLY reply in the following format with NO suffix:
<tool_call>
<function=example_function_name>
<parameter=example_parameter_1>
value_1
</parameter>
<parameter=example_parameter_2>
value_2
</parameter>
</function>
</tool_call>
<IMPORTANT>
Reminder:
- Function calls MUST follow the specified format: the tool calling block MUST begin with an opening <tool_call> tag and end with a closing </tool_call> tag.
- Required parameters MUST be specified
- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after
- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls
</IMPORTANT><|im_end|>
<|im_start|>'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<|im_start|>user
Hello, please help me.<|im_end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): '<|im_start|>assistant
'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
I can help you with that.<|im_end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
I can help you with that.<|im_end|>
<|im_start|>user
Thank you.<|im_end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<|im_start|>system
You are Qwen, a helpful AI assistant that can interact with a computer to solve tasks.
# Tools
You have access to the following tools:
<tools>
<function>
<name>test_function_name</name>
<description>A test function for debugging</description>
<parameters>
<parameter>
<name>param1</name>
<type>string</type>
<description>First parameter</description>
</parameter>
<parameter>
<name>param2</name>
<type>string</type>
<description>Second parameter</description>
</parameter>
<required>["param1", "param2"]</required>
</parameters>
</function>
</tools>
If you choose to call a tool ONLY reply in the following format with NO suffix:
<tool_call>
<function=example_function_name>
<parameter=example_parameter_1>
value_1
</parameter>
<parameter=example_parameter_2>
value_2
</parameter>
</function>
</tool_call>
<IMPORTANT>
Reminder:
- Function calls MUST follow the specified format: the tool calling block MUST begin with an opening <tool_call> tag and end with a closing </tool_call> tag.
- Required parameters MUST be specified
- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after
- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls
</IMPORTANT><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
'
Common Suffix: '<|im_end|>
'
Left (difference): 'Let me help you.'
Right (difference): '<tool_call>
<function=test_function_name>
<parameter=param1>
value1
</parameter>
<parameter=param2>
value2
</parameter>
</function>
</tool_call>'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<|im_start|>system
You are Qwen, a helpful AI assistant that can interact with a computer to solve tasks.
# Tools
You have access to the following tools:
<tools>
<function>
<name>test_function_name</name>
<description>A test function for debugging</description>
<parameters>
<parameter>
<name>param1</name>
<type>string</type>
<description>First parameter</description>
</parameter>
<parameter>
<name>param2</name>
<type>string</type>
<description>Second parameter</description>
</parameter>
<required>["param1", "param2"]</required>
</parameters>
</function>
</tools>
If you choose to call a tool ONLY reply in the following format with NO suffix:
<tool_call>
<function=example_function_name>
<parameter=example_parameter_1>
value_1
</parameter>
<parameter=example_parameter_2>
value_2
</parameter>
</function>
</tool_call>
<IMPORTANT>
Reminder:
- Function calls MUST follow the specified format: the tool calling block MUST begin with an opening <tool_call> tag and end with a closing </tool_call> tag.
- Required parameters MUST be specified
- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after
- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls
</IMPORTANT><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
'
Common Suffix: '<|im_end|>
<|im_start|>user
Continue.<|im_end|>
'
Left (difference): 'Let me help you.'
Right (difference): '<tool_call>
<function=test_function_name>
<parameter=param1>
value1
</parameter>
<parameter=param2>
value2
</parameter>
</function>
</tool_call>'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '<|im_start|>system
You are Qwen, a helpful AI assistant that can interact with a computer to solve tasks.
# Tools
You have access to the following tools:
<tools>
<function>
<name>test_function_name</name>
<description>A test function for debugging</description>
<parameters>
<parameter>
<name>param1</name>
<type>string</type>
<description>First parameter</description>
</parameter>
<parameter>
<name>param2</name>
<type>string</type>
<description>Second parameter</description>
</parameter>
<required>["param1", "param2"]</required>
</parameters>
</function>
</tools>
If you choose to call a tool ONLY reply in the following format with NO suffix:
<tool_call>
<function=example_function_name>
<parameter=example_parameter_1>
value_1
</parameter>
<parameter=example_parameter_2>
value_2
</parameter>
</function>
</tool_call>
<IMPORTANT>
Reminder:
- Function calls MUST follow the specified format: the tool calling block MUST begin with an opening <tool_call> tag and end with a closing </tool_call> tag.
- Required parameters MUST be specified
- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after
- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls
</IMPORTANT><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
<tool_call>
<function=test_function_name>
<parameter=param1>
value1
</parameter>
<parameter=param2>
value2
</parameter>
</function>
</tool_call>'
Common Suffix: '<|im_end|>
'
Left (difference): ''
Right (difference): '
<tool_call>
<function=test_function_name>
<parameter=param1>
value3
</parameter>
<parameter=param2>
value4
</parameter>
</function>
</tool_call>'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '<|im_start|>system
You are Qwen, a helpful AI assistant that can interact with a computer to solve tasks.
# Tools
You have access to the following tools:
<tools>
<function>
<name>test_function_name</name>
<description>A test function for debugging</description>
<parameters>
<parameter>
<name>param1</name>
<type>string</type>
<description>First parameter</description>
</parameter>
<parameter>
<name>param2</name>
<type>string</type>
<description>Second parameter</description>
</parameter>
<required>["param1", "param2"]</required>
</parameters>
</function>
</tools>
If you choose to call a tool ONLY reply in the following format with NO suffix:
<tool_call>
<function=example_function_name>
<parameter=example_parameter_1>
value_1
</parameter>
<parameter=example_parameter_2>
value_2
</parameter>
</function>
</tool_call>
<IMPORTANT>
Reminder:
- Function calls MUST follow the specified format: the tool calling block MUST begin with an opening <tool_call> tag and end with a closing </tool_call> tag.
- Required parameters MUST be specified
- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after
- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls
</IMPORTANT><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
<tool_call>
<function=test_function_name>
<parameter=param1>
value1
</parameter>
<parameter=param2>
value2
</parameter>
</function>
</tool_call>'
Common Suffix: '<|im_end|>
<|im_start|>user
Continue.<|im_end|>
'
Left (difference): ''
Right (difference): '
<tool_call>
<function=test_function_name>
<parameter=param1>
value3
</parameter>
<parameter=param2>
value4
</parameter>
</function>
</tool_call>'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '<|im_start|>system
You are Qwen, a helpful AI assistant that can interact with a computer to solve tasks.
# Tools
You have access to the following tools:
<tools>
<function>
<name>test_function_name</name>
<description>A test function for debugging</description>
<parameters>
<parameter>
<name>param1</name>
<type>string</type>
<description>First parameter</description>
</parameter>
<parameter>
<name>param2</name>
<type>string</type>
<description>Second parameter</description>
</parameter>
<required>["param1", "param2"]</required>
</parameters>
</function>
</tools>
If you choose to call a tool ONLY reply in the following format with NO suffix:
<tool_call>
<function=example_function_name>
<parameter=example_parameter_1>
value_1
</parameter>
<parameter=example_parameter_2>
value_2
</parameter>
</function>
</tool_call>
<IMPORTANT>
Reminder:
- Function calls MUST follow the specified format: the tool calling block MUST begin with an opening <tool_call> tag and end with a closing </tool_call> tag.
- Required parameters MUST be specified
- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after
- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls
</IMPORTANT><|im_end|>
<|im_start|>user
Hello, please help me.<|im_end|>
<|im_start|>assistant
<tool_call>
<function=test_function_name>
<parameter=param1>
value1
</parameter>
<parameter=param2>
value2
</parameter>
</function>
</tool_call><|im_end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/deepseek-ai-DeepSeek-R1-Distill-Llama-8B.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: false
supports_system_role: true
supports_parallel_tool_calls: false
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<｜User｜>Hello, please help me.'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<｜User｜>Hello, please help me.'
Common Suffix: ''
Left (difference): ''
Right (difference): '<｜Assistant｜><think>
'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<｜User｜>Hello, please help me.<｜Assistant｜>I can help you with that.<｜end▁of▁sentence｜>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<｜User｜>Hello, please help me.<｜Assistant｜>I can help you with that.<｜end▁of▁sentence｜><｜User｜>Thank you.'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<｜User｜>Hello, please help me.<｜Assistant｜>'
Common Suffix: ''
Left (difference): 'Let me help you.<｜end▁of▁sentence｜>'
Right (difference): '<｜tool▁calls▁begin｜><｜tool▁call▁begin｜>function<｜tool▁sep｜>test_function_name
```json
{"param1":0x6414d8b028d0, "param2":0x6414d8abda40}
```<｜tool▁call▁end｜>'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<｜User｜>Hello, please help me.<｜Assistant｜>'
Common Suffix: '<｜User｜>Continue.'
Left (difference): 'Let me help you.<｜end▁of▁sentence｜>'
Right (difference): '<｜tool▁calls▁begin｜><｜tool▁call▁begin｜>function<｜tool▁sep｜>test_function_name
```json
{"param1":0x6414d8abea30, "param2":0x6414d8aba0e0}
```<｜tool▁call▁end｜>'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '<｜User｜>Hello, please help me.<｜Assistant｜><｜tool▁calls▁begin｜><｜tool▁call▁begin｜>function<｜tool▁sep｜>test_function_name
```json
{"param1":0x6414d8a'
Common Suffix: ''
Left (difference): 'ce970, "param2":0x6414d8abbb70}
```<｜tool▁call▁end｜>'
Right (difference): 'b5ac0, "param2":0x6414d8aba960}
```<｜tool▁call▁end｜>
<｜tool▁call▁begin｜>function<｜tool▁sep｜>test_function_name
```json
{"param1":0x6414d8b09df0, "param2":0x6414d8b0d3a0}
```<｜tool▁call▁end｜><｜tool▁calls▁end｜><｜end▁of▁sentence｜>'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '<｜User｜>Hello, please help me.<｜Assistant｜><｜tool▁calls▁begin｜><｜tool▁call▁begin｜>function<｜tool▁sep｜>test_function_name
```json
{"param1":0x6414d8'
Common Suffix: '<｜User｜>Continue.'
Left (difference): 'abb400, "param2":0x6414d8aff760}
```<｜tool▁call▁end｜>'
Right (difference): 'b17be0, "param2":0x6414d8ab7550}
```<｜tool▁call▁end｜>
<｜tool▁call▁begin｜>function<｜tool▁sep｜>test_function_name
```json
{"param1":0x6414d8aba960, "param2":0x6414d8ab5ac0}
```<｜tool▁call▁end｜><｜tool▁calls▁end｜><｜end▁of▁sentence｜>'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '<｜User｜>Hello, please help me.<｜Assistant｜><｜tool▁calls▁begin｜><｜tool▁call▁begin｜>function<｜tool▁sep｜>test_function_name
```json
{"param1":0x6414d8a'
Common Suffix: '0}
```<｜tool▁call▁end｜>'
Left (difference): 'def30, "param2":0x6414d8aba0e'
Right (difference): 'be4e0, "param2":0x6414d8ae266'
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/deepseek-ai-DeepSeek-R1-Distill-Qwen-32B.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: false
supports_system_role: true
supports_parallel_tool_calls: false
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<｜User｜>Hello, please help me.'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<｜User｜>Hello, please help me.'
Common Suffix: ''
Left (difference): ''
Right (difference): '<｜Assistant｜><think>
'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<｜User｜>Hello, please help me.<｜Assistant｜>I can help you with that.<｜end▁of▁sentence｜>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<｜User｜>Hello, please help me.<｜Assistant｜>I can help you with that.<｜end▁of▁sentence｜><｜User｜>Thank you.'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<｜User｜>Hello, please help me.<｜Assistant｜>'
Common Suffix: '<｜end▁of▁sentence｜>'
Left (difference): 'Let me help you.'
Right (difference): '<｜tool▁calls▁begin｜><｜tool▁call▁begin｜>function<｜tool▁sep｜>test_function_name
```json
{"param1":0x6414d8ab9ec0, "param2":0x6414d8ac6240}
```<｜tool▁call▁end｜><｜tool▁calls▁end｜>'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<｜User｜>Hello, please help me.<｜Assistant｜>'
Common Suffix: '<｜end▁of▁sentence｜><｜User｜>Continue.'
Left (difference): 'Let me help you.'
Right (difference): '<｜tool▁calls▁begin｜><｜tool▁call▁begin｜>function<｜tool▁sep｜>test_function_name
```json
{"param1":0x6414d8aeabd0, "param2":0x6414d8abda40}
```<｜tool▁call▁end｜><｜tool▁calls▁end｜>'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '<｜User｜>Hello, please help me.<｜Assistant｜><｜tool▁calls▁begin｜><｜tool▁call▁begin｜>function<｜tool▁sep｜>test_function_name
```json
{"param1":0x6414d8ab'
Common Suffix: '0}
```<｜tool▁call▁end｜><｜tool▁calls▁end｜><｜end▁of▁sentence｜>'
Left (difference): 'b620, "param2":0x6414d8abd82'
Right (difference): '9420, "param2":0x6414d8ac14b0}
```<｜tool▁call▁end｜>
<｜tool▁call▁begin｜>function<｜tool▁sep｜>test_function_name
```json
{"param1":0x6414d8abbb70, "param2":0x6414d8abda4'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '<｜User｜>Hello, please help me.<｜Assistant｜><｜tool▁calls▁begin｜><｜tool▁call▁begin｜>function<｜tool▁sep｜>test_function_name
```json
{"param1":0x6414d8a'
Common Suffix: '0}
```<｜tool▁call▁end｜><｜tool▁calls▁end｜><｜end▁of▁sentence｜><｜User｜>Continue.'
Left (difference): 'c4150, "param2":0x6414d8abf2b'
Right (difference): 'bea30, "param2":0x6414d8aba410}
```<｜tool▁call▁end｜>
<｜tool▁call▁begin｜>function<｜tool▁sep｜>test_function_name
```json
{"param1":0x6414d8ab9420, "param2":0x6414d8ac46a'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '<｜User｜>Hello, please help me.<｜Assistant｜><｜tool▁calls▁begin｜><｜tool▁call▁begin｜>function<｜tool▁sep｜>test_function_name
```json
{"param1":0x6414d8ab'
Common Suffix: '0}
```<｜tool▁call▁end｜><｜tool▁calls▁end｜><｜end▁of▁sentence｜>'
Left (difference): '5ac0, "param2":0x6414d8adef3'
Right (difference): 'a960, "param2":0x6414d8ac4bf'
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/deepseek-ai-DeepSeek-V3.1.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<｜User｜>Hello, please help me.'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<｜User｜>Hello, please help me.'
Common Suffix: ''
Left (difference): ''
Right (difference): '<｜Assistant｜><think>'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<｜User｜>Hello, please help me.<｜Assistant｜></think>I can help you with that.<｜end▁of▁sentence｜>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<｜User｜>Hello, please help me.<｜Assistant｜></think>I can help you with that.<｜end▁of▁sentence｜><｜User｜>Thank you.'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<｜User｜>Hello, please help me.<｜Assistant｜></think>'
Common Suffix: '<｜end▁of▁sentence｜>'
Left (difference): 'Let me help you.'
Right (difference): '<｜tool▁calls▁begin｜><｜tool▁call▁begin｜>test_function_name<｜tool▁sep｜>{"param1":0x6414d8ae5a10, "param2":0x6414d8abe810}<｜tool▁call▁end｜><｜tool▁calls▁end｜>'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<｜User｜>Hello, please help me.<｜Assistant｜></think>'
Common Suffix: '<｜end▁of▁sentence｜><｜User｜>Continue.'
Left (difference): 'Let me help you.'
Right (difference): '<｜tool▁calls▁begin｜><｜tool▁call▁begin｜>test_function_name<｜tool▁sep｜>{"param1":0x6414d8ac7cb0, "param2":0x6414d8abe4e0}<｜tool▁call▁end｜><｜tool▁calls▁end｜>'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '<｜User｜>Hello, please help me.<｜Assistant｜></think><｜tool▁calls▁begin｜><｜tool▁call▁begin｜>test_function_name<｜tool▁sep｜>{"param1":0x6414d8a'
Common Suffix: '0}<｜tool▁call▁end｜><｜tool▁calls▁end｜><｜end▁of▁sentence｜>'
Left (difference): 'c5f10, "param2":0x6414d8ac59c'
Right (difference): 'be4e0, "param2":0x6414d8ac2e30}<｜tool▁call▁end｜><｜tool▁call▁begin｜>test_function_name<｜tool▁sep｜>{"param1":0x6414d8acbf00, "param2":0x6414d8ac7cb'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '<｜User｜>Hello, please help me.<｜Assistant｜></think><｜tool▁calls▁begin｜><｜tool▁call▁begin｜>test_function_name<｜tool▁sep｜>{"param1":0x6414d8'
Common Suffix: '0}<｜tool▁call▁end｜><｜tool▁calls▁end｜><｜end▁of▁sentence｜><｜User｜>Continue.'
Left (difference): 'b0a810, "param2":0x6414d8adf7b'
Right (difference): 'ac2e30, "param2":0x6414d8ac46a0}<｜tool▁call▁end｜><｜tool▁call▁begin｜>test_function_name<｜tool▁sep｜>{"param1":0x6414d8ac3e20, "param2":0x6414d8abe4e'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '<｜User｜>Hello, please help me.<｜Assistant｜></think><｜tool▁calls▁begin｜><｜tool▁call▁begin｜>test_function_name<｜tool▁sep｜>{"param1":0x6414d8ac'
Common Suffix: '0}<｜tool▁call▁end｜><｜tool▁calls▁end｜><｜end▁of▁sentence｜>'
Left (difference): '7cb0, "param2":0x6414d8ad63e'
Right (difference): '59c0, "param2":0x6414d8abc0c'
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/fireworks-ai-llama-3-firefunction-v2.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
You are a helpful assistant with access to functions.
In addition to plain text responses, you can chose to call one or more of the provided functions.
Use the following rule to decide when to call a function:
* if the response can be generated from your internal knowledge (e.g., as in the case of queries like "What is the capital of Poland?"), do so
* if you need external information that can be obtained by calling one or more of the provided functions, generate a function calls
If you decide to call functions:
* prefix function calls with functools marker (no closing marker required)
* all function calls should be generated in a single JSON list formatted as functools[{"name": [function name], "arguments": [function arguments as JSON]}, ...]
* follow the provided JSON schema. Do not hallucinate arguments or values. Do to blindly copy values from the provided samples
* respect the argument type formatting. E.g., if the type if number and format is float, write value 7 as 7.0
* make sure you pick the right functions that match the user intent
Available functions as JSON spec:
Today is .<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
You are a helpful assistant with access to functions.
In addition to plain text responses, you can chose to call one or more of the provided functions.
Use the following rule to decide when to call a function:
* if the response can be generated from your internal knowledge (e.g., as in the case of queries like "What is the capital of Poland?"), do so
* if you need external information that can be obtained by calling one or more of the provided functions, generate a function calls
If you decide to call functions:
* prefix function calls with functools marker (no closing marker required)
* all function calls should be generated in a single JSON list formatted as functools[{"name": [function name], "arguments": [function arguments as JSON]}, ...]
* follow the provided JSON schema. Do not hallucinate arguments or values. Do to blindly copy values from the provided samples
* respect the argument type formatting. E.g., if the type if number and format is float, write value 7 as 7.0
* make sure you pick the right functions that match the user intent
Available functions as JSON spec:
Today is .<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
You are a helpful assistant with access to functions.
In addition to plain text responses, you can chose to call one or more of the provided functions.
Use the following rule to decide when to call a function:
* if the response can be generated from your internal knowledge (e.g., as in the case of queries like "What is the capital of Poland?"), do so
* if you need external information that can be obtained by calling one or more of the provided functions, generate a function calls
If you decide to call functions:
* prefix function calls with functools marker (no closing marker required)
* all function calls should be generated in a single JSON list formatted as functools[{"name": [function name], "arguments": [function arguments as JSON]}, ...]
* follow the provided JSON schema. Do not hallucinate arguments or values. Do to blindly copy values from the provided samples
* respect the argument type formatting. E.g., if the type if number and format is float, write value 7 as 7.0
* make sure you pick the right functions that match the user intent
Available functions as JSON spec:
Today is .<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
I can help you with that.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
You are a helpful assistant with access to functions.
In addition to plain text responses, you can chose to call one or more of the provided functions.
Use the following rule to decide when to call a function:
* if the response can be generated from your internal knowledge (e.g., as in the case of queries like "What is the capital of Poland?"), do so
* if you need external information that can be obtained by calling one or more of the provided functions, generate a function calls
If you decide to call functions:
* prefix function calls with functools marker (no closing marker required)
* all function calls should be generated in a single JSON list formatted as functools[{"name": [function name], "arguments": [function arguments as JSON]}, ...]
* follow the provided JSON schema. Do not hallucinate arguments or values. Do to blindly copy values from the provided samples
* respect the argument type formatting. E.g., if the type if number and format is float, write value 7 as 7.0
* make sure you pick the right functions that match the user intent
Available functions as JSON spec:
Today is .<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
I can help you with that.<|eot_id|><|start_header_id|>user<|end_header_id|>
Thank you.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
You are a helpful assistant with access to functions.
In addition to plain text responses, you can chose to call one or more of the provided functions.
Use the following rule to decide when to call a function:
* if the response can be generated from your internal knowledge (e.g., as in the case of queries like "What is the capital of Poland?"), do so
* if you need external information that can be obtained by calling one or more of the provided functions, generate a function calls
If you decide to call functions:
* prefix function calls with functools marker (no closing marker required)
* all function calls should be generated in a single JSON list formatted as functools[{"name": [function name], "arguments": [function arguments as JSON]}, ...]
* follow the provided JSON schema. Do not hallucinate arguments or values. Do to blindly copy values from the provided samples
* respect the argument type formatting. E.g., if the type if number and format is float, write value 7 as 7.0
* make sure you pick the right functions that match the user intent
Available functions as JSON spec:
Today is .<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
'
Common Suffix: '<|eot_id|><|start_header_id|>assistant<|end_header_id|>
'
Left (difference): 'Let me help you.'
Right (difference): ' functools[{"name": "test_function_name", "arguments": {"param1":0x6414d8ab9970, "param2":0x6414d8ac3380}}]'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
You are a helpful assistant with access to functions.
In addition to plain text responses, you can chose to call one or more of the provided functions.
Use the following rule to decide when to call a function:
* if the response can be generated from your internal knowledge (e.g., as in the case of queries like "What is the capital of Poland?"), do so
* if you need external information that can be obtained by calling one or more of the provided functions, generate a function calls
If you decide to call functions:
* prefix function calls with functools marker (no closing marker required)
* all function calls should be generated in a single JSON list formatted as functools[{"name": [function name], "arguments": [function arguments as JSON]}, ...]
* follow the provided JSON schema. Do not hallucinate arguments or values. Do to blindly copy values from the provided samples
* respect the argument type formatting. E.g., if the type if number and format is float, write value 7 as 7.0
* make sure you pick the right functions that match the user intent
Available functions as JSON spec:
Today is .<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
'
Common Suffix: '<|eot_id|><|start_header_id|>user<|end_header_id|>
Continue.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
'
Left (difference): 'Let me help you.'
Right (difference): ' functools[{"name": "test_function_name", "arguments": {"param1":0x6414d8b04f50, "param2":0x6414d8ab6cd0}}]'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
You are a helpful assistant with access to functions.
In addition to plain text responses, you can chose to call one or more of the provided functions.
Use the following rule to decide when to call a function:
* if the response can be generated from your internal knowledge (e.g., as in the case of queries like "What is the capital of Poland?"), do so
* if you need external information that can be obtained by calling one or more of the provided functions, generate a function calls
If you decide to call functions:
* prefix function calls with functools marker (no closing marker required)
* all function calls should be generated in a single JSON list formatted as functools[{"name": [function name], "arguments": [function arguments as JSON]}, ...]
* follow the provided JSON schema. Do not hallucinate arguments or values. Do to blindly copy values from the provided samples
* respect the argument type formatting. E.g., if the type if number and format is float, write value 7 as 7.0
* make sure you pick the right functions that match the user intent
Available functions as JSON spec:
Today is .<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
functools[{"name": "test_function_name", "arguments": {"param1":0x6414d8a'
Common Suffix: '0}}]<|eot_id|><|start_header_id|>assistant<|end_header_id|>
'
Left (difference): 'bb950, "param2":0x6414d8abb40'
Right (difference): 'c1290, "param2":0x6414d8abf2b0}}, {"name": "test_function_name", "arguments": {"param1":0x6414d8b04f50, "param2":0x6414d8adef3'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
You are a helpful assistant with access to functions.
In addition to plain text responses, you can chose to call one or more of the provided functions.
Use the following rule to decide when to call a function:
* if the response can be generated from your internal knowledge (e.g., as in the case of queries like "What is the capital of Poland?"), do so
* if you need external information that can be obtained by calling one or more of the provided functions, generate a function calls
If you decide to call functions:
* prefix function calls with functools marker (no closing marker required)
* all function calls should be generated in a single JSON list formatted as functools[{"name": [function name], "arguments": [function arguments as JSON]}, ...]
* follow the provided JSON schema. Do not hallucinate arguments or values. Do to blindly copy values from the provided samples
* respect the argument type formatting. E.g., if the type if number and format is float, write value 7 as 7.0
* make sure you pick the right functions that match the user intent
Available functions as JSON spec:
Today is .<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
functools[{"name": "test_function_name", "arguments": {"param1":0x6414d8a'
Common Suffix: '0}}]<|eot_id|><|start_header_id|>user<|end_header_id|>
Continue.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
'
Left (difference): 'c4150, "param2":0x6414d8b103a'
Right (difference): 'bed60, "param2":0x6414d8ae0430}}, {"name": "test_function_name", "arguments": {"param1":0x6414d8adef30, "param2":0x6414d8b04f5'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
You are a helpful assistant with access to functions.
In addition to plain text responses, you can chose to call one or more of the provided functions.
Use the following rule to decide when to call a function:
* if the response can be generated from your internal knowledge (e.g., as in the case of queries like "What is the capital of Poland?"), do so
* if you need external information that can be obtained by calling one or more of the provided functions, generate a function calls
If you decide to call functions:
* prefix function calls with functools marker (no closing marker required)
* all function calls should be generated in a single JSON list formatted as functools[{"name": [function name], "arguments": [function arguments as JSON]}, ...]
* follow the provided JSON schema. Do not hallucinate arguments or values. Do to blindly copy values from the provided samples
* respect the argument type formatting. E.g., if the type if number and format is float, write value 7 as 7.0
* make sure you pick the right functions that match the user intent
Available functions as JSON spec:
Today is .<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
functools[{"name": "test_function_name", "arguments": {"param1":0x6414d8a'
Common Suffix: '0}}]<|eot_id|><|start_header_id|>assistant<|end_header_id|>
'
Left (difference): 'c46a0, "param2":0x6414d8b2231'
Right (difference): 'bb950, "param2":0x6414d8abb40'
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/google-gemma-2-2b-it.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: false
supports_system_role: false
supports_parallel_tool_calls: false
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<start_of_turn>user
Hello, please help me.<end_of_turn>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<start_of_turn>user
Hello, please help me.<end_of_turn>
'
Common Suffix: ''
Left (difference): ''
Right (difference): '<start_of_turn>model
'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<start_of_turn>user
Hello, please help me.<end_of_turn>
<start_of_turn>model
I can help you with that.<end_of_turn>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<start_of_turn>user
Hello, please help me.<end_of_turn>
<start_of_turn>model
I can help you with that.<end_of_turn>
<start_of_turn>user
Thank you.<end_of_turn>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<start_of_turn>user
Hello, please help me.<end_of_turn>
<start_of_turn>model
'
Common Suffix: '<end_of_turn>
'
Left (difference): 'Let me help you.'
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<start_of_turn>user
Hello, please help me.<end_of_turn>
<start_of_turn>model
'
Common Suffix: '<end_of_turn>
<start_of_turn>user
Continue.<end_of_turn>
'
Left (difference): 'Let me help you.'
Right (difference): ''
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '<start_of_turn>user
Hello, please help me.<end_of_turn>
<start_of_turn>model
<end_of_turn>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '<start_of_turn>user
Hello, please help me.<end_of_turn>
<start_of_turn>model
<end_of_turn>
<start_of_turn>user
Continue.<end_of_turn>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '<start_of_turn>user
Hello, please help me.<end_of_turn>
<start_of_turn>model
<end_of_turn>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/ibm-granite-granite-3.3-2B-Instruct.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: false
supports_system_role: true
supports_parallel_tool_calls: false
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<|start_of_role|>system<|end_of_role|>Knowledge Cutoff Date: April 2024. Today's Date: January 26, 2026. You are Granite, developed by IBM. You are a helpful '
Common Suffix: '<|end_of_text|>
<|start_of_role|>user<|end_of_role|>Hello, please help me.<|end_of_text|>
'
Left (difference): 'AI assistant.'
Right (difference): 'assistant with access to the following tools. When a tool is required to answer the user's query, respond only with <|tool_call|> followed by a JSON list of tools used. If a tool does not exist in the provided list of tools, notify the user that you do not have the ability to fulfill the request.<|end_of_text|>
<|start_of_role|>available_tools<|end_of_role|>[
{
"type": "function",
"function": {
"name": "test_function_name",
"description": "A test function for debugging",
"parameters": {
"type": "object",
"properties": {
"param1": {
"type": "string",
"description": "First parameter"
},
"param2": {
"type": "string",
"description": "Second parameter"
}
},
"required": [
"param1",
"param2"
]
}
}
}
]'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<|start_of_role|>system<|end_of_role|>Knowledge Cutoff Date: April 2024. Today's Date: January 26, 2026. You are Granite, developed by IBM. You are a helpful AI assistant.<|end_of_text|>
<|start_of_role|>user<|end_of_role|>Hello, please help me.<|end_of_text|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): '<|start_of_role|>assistant<|end_of_role|>'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<|start_of_role|>system<|end_of_role|>Knowledge Cutoff Date: April 2024. Today's Date: January 26, 2026. You are Granite, developed by IBM. You are a helpful AI assistant.<|end_of_text|>
<|start_of_role|>user<|end_of_role|>Hello, please help me.<|end_of_text|>
<|start_of_role|>assistant<|end_of_role|>I can help you with that.<|end_of_text|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<|start_of_role|>system<|end_of_role|>Knowledge Cutoff Date: April 2024. Today's Date: January 26, 2026. You are Granite, developed by IBM. You are a helpful AI assistant.<|end_of_text|>
<|start_of_role|>user<|end_of_role|>Hello, please help me.<|end_of_text|>
<|start_of_role|>assistant<|end_of_role|>I can help you with that.<|end_of_text|>
<|start_of_role|>user<|end_of_role|>Thank you.<|end_of_text|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<|start_of_role|>system<|end_of_role|>Knowledge Cutoff Date: April 2024. Today's Date: January 26, 2026. You are Granite, developed by IBM. You are a helpful assistant with access to the following tools. When a tool is required to answer the user's query, respond only with <|tool_call|> followed by a JSON list of tools used. If a tool does not exist in the provided list of tools, notify the user that you do not have the ability to fulfill the request.<|end_of_text|>
<|start_of_role|>available_tools<|end_of_role|>[
{
"type": "function",
"function": {
"name": "test_function_name",
"description": "A test function for debugging",
"parameters": {
"type": "object",
"properties": {
"param1": {
"type": "string",
"description": "First parameter"
},
"param2": {
"type": "string",
"description": "Second parameter"
}
},
"required": [
"param1",
"param2"
]
}
}
}
]<|end_of_text|>
<|start_of_role|>user<|end_of_role|>Hello, please help me.<|end_of_text|>
<|start_of_role|>assistant<|end_of_role|>'
Common Suffix: '<|end_of_text|>
'
Left (difference): 'Let me help you.'
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<|start_of_role|>system<|end_of_role|>Knowledge Cutoff Date: April 2024. Today's Date: January 26, 2026. You are Granite, developed by IBM. You are a helpful assistant with access to the following tools. When a tool is required to answer the user's query, respond only with <|tool_call|> followed by a JSON list of tools used. If a tool does not exist in the provided list of tools, notify the user that you do not have the ability to fulfill the request.<|end_of_text|>
<|start_of_role|>available_tools<|end_of_role|>[
{
"type": "function",
"function": {
"name": "test_function_name",
"description": "A test function for debugging",
"parameters": {
"type": "object",
"properties": {
"param1": {
"type": "string",
"description": "First parameter"
},
"param2": {
"type": "string",
"description": "Second parameter"
}
},
"required": [
"param1",
"param2"
]
}
}
}
]<|end_of_text|>
<|start_of_role|>user<|end_of_role|>Hello, please help me.<|end_of_text|>
<|start_of_role|>assistant<|end_of_role|>'
Common Suffix: '<|end_of_text|>
<|start_of_role|>user<|end_of_role|>Continue.<|end_of_text|>
'
Left (difference): 'Let me help you.'
Right (difference): ''
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '<|start_of_role|>system<|end_of_role|>Knowledge Cutoff Date: April 2024. Today's Date: January 26, 2026. You are Granite, developed by IBM. You are a helpful assistant with access to the following tools. When a tool is required to answer the user's query, respond only with <|tool_call|> followed by a JSON list of tools used. If a tool does not exist in the provided list of tools, notify the user that you do not have the ability to fulfill the request.<|end_of_text|>
<|start_of_role|>available_tools<|end_of_role|>[
{
"type": "function",
"function": {
"name": "test_function_name",
"description": "A test function for debugging",
"parameters": {
"type": "object",
"properties": {
"param1": {
"type": "string",
"description": "First parameter"
},
"param2": {
"type": "string",
"description": "Second parameter"
}
},
"required": [
"param1",
"param2"
]
}
}
}
]<|end_of_text|>
<|start_of_role|>user<|end_of_role|>Hello, please help me.<|end_of_text|>
<|start_of_role|>assistant<|end_of_role|><|end_of_text|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '<|start_of_role|>system<|end_of_role|>Knowledge Cutoff Date: April 2024. Today's Date: January 26, 2026. You are Granite, developed by IBM. You are a helpful assistant with access to the following tools. When a tool is required to answer the user's query, respond only with <|tool_call|> followed by a JSON list of tools used. If a tool does not exist in the provided list of tools, notify the user that you do not have the ability to fulfill the request.<|end_of_text|>
<|start_of_role|>available_tools<|end_of_role|>[
{
"type": "function",
"function": {
"name": "test_function_name",
"description": "A test function for debugging",
"parameters": {
"type": "object",
"properties": {
"param1": {
"type": "string",
"description": "First parameter"
},
"param2": {
"type": "string",
"description": "Second parameter"
}
},
"required": [
"param1",
"param2"
]
}
}
}
]<|end_of_text|>
<|start_of_role|>user<|end_of_role|>Hello, please help me.<|end_of_text|>
<|start_of_role|>assistant<|end_of_role|><|end_of_text|>
<|start_of_role|>user<|end_of_role|>Continue.<|end_of_text|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '<|start_of_role|>system<|end_of_role|>Knowledge Cutoff Date: April 2024. Today's Date: January 26, 2026. You are Granite, developed by IBM. You are a helpful assistant with access to the following tools. When a tool is required to answer the user's query, respond only with <|tool_call|> followed by a JSON list of tools used. If a tool does not exist in the provided list of tools, notify the user that you do not have the ability to fulfill the request.<|end_of_text|>
<|start_of_role|>available_tools<|end_of_role|>[
{
"type": "function",
"function": {
"name": "test_function_name",
"description": "A test function for debugging",
"parameters": {
"type": "object",
"properties": {
"param1": {
"type": "string",
"description": "First parameter"
},
"param2": {
"type": "string",
"description": "Second parameter"
}
},
"required": [
"param1",
"param2"
]
}
}
}
]<|end_of_text|>
<|start_of_role|>user<|end_of_role|>Hello, please help me.<|end_of_text|>
<|start_of_role|>assistant<|end_of_role|><|end_of_text|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/llama-cpp-deepseek-r1.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: false
supports_system_role: true
supports_parallel_tool_calls: false
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: ''
Common Suffix: '<｜User｜>Hello, please help me.<｜end▁of▁sentence｜>'
Left (difference): ''
Right (difference): 'You can call any of the following function tools to satisfy the user's requests: [
{
"name": "test_function_name",
"description": "A test function for debugging",
"parameters": {
"type": "object",
"properties": {
"param1": {
"type": "string",
"description": "First parameter"
},
"param2": {
"type": "string",
"description": "Second parameter"
}
},
"required": [
"param1",
"param2"
]
}
}
]
Example function tool call syntax:
<｜tool▁calls▁begin｜><｜tool▁call▁begin｜>function<｜tool▁sep｜>example_function_name
```json
{
"arg1": "some_value"
...
}
```
<｜tool▁call▁end｜><｜tool▁calls▁end｜>
'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<｜User｜>Hello, please help me.<｜end▁of▁sentence｜>'
Common Suffix: ''
Left (difference): ''
Right (difference): '<｜Assistant｜><think>
'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<｜User｜>Hello, please help me.<｜end▁of▁sentence｜><｜Assistant｜>I can help you with that.<｜end▁of▁sentence｜>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<｜User｜>Hello, please help me.<｜end▁of▁sentence｜><｜Assistant｜>I can help you with that.<｜end▁of▁sentence｜><｜User｜>Thank you.<｜end▁of▁sentence｜>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: 'You can call any of the following function tools to satisfy the user's requests: [
{
"name": "test_function_name",
"description": "A test function for debugging",
"parameters": {
"type": "object",
"properties": {
"param1": {
"type": "string",
"description": "First parameter"
},
"param2": {
"type": "string",
"description": "Second parameter"
}
},
"required": [
"param1",
"param2"
]
}
}
]
Example function tool call syntax:
<｜tool▁calls▁begin｜><｜tool▁call▁begin｜>function<｜tool▁sep｜>example_function_name
```json
{
"arg1": "some_value"
...
}
```
<｜tool▁call▁end｜><｜tool▁calls▁end｜>
<｜User｜>Hello, please help me.<｜end▁of▁sentence｜><｜Assistant｜>'
Common Suffix: '<｜end▁of▁sentence｜>'
Left (difference): 'Let me help you.'
Right (difference): '<｜tool▁calls▁begin｜><｜tool▁call▁begin｜>function<｜tool▁sep｜>test_function_name
```json
{"param1":0x6414d8b06690, "param2":0x6414d8abf070}
```<｜tool▁call▁end｜><｜tool▁calls▁end｜>'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: 'You can call any of the following function tools to satisfy the user's requests: [
{
"name": "test_function_name",
"description": "A test function for debugging",
"parameters": {
"type": "object",
"properties": {
"param1": {
"type": "string",
"description": "First parameter"
},
"param2": {
"type": "string",
"description": "Second parameter"
}
},
"required": [
"param1",
"param2"
]
}
}
]
Example function tool call syntax:
<｜tool▁calls▁begin｜><｜tool▁call▁begin｜>function<｜tool▁sep｜>example_function_name
```json
{
"arg1": "some_value"
...
}
```
<｜tool▁call▁end｜><｜tool▁calls▁end｜>
<｜User｜>Hello, please help me.<｜end▁of▁sentence｜><｜Assistant｜>'
Common Suffix: '<｜end▁of▁sentence｜><｜User｜>Continue.<｜end▁of▁sentence｜>'
Left (difference): 'Let me help you.'
Right (difference): '<｜tool▁calls▁begin｜><｜tool▁call▁begin｜>function<｜tool▁sep｜>test_function_name
```json
{"param1":0x6414d8acb270, "param2":0x6414d8ab6cd0}
```<｜tool▁call▁end｜><｜tool▁calls▁end｜>'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: 'You can call any of the following function tools to satisfy the user's requests: [
{
"name": "test_function_name",
"description": "A test function for debugging",
"parameters": {
"type": "object",
"properties": {
"param1": {
"type": "string",
"description": "First parameter"
},
"param2": {
"type": "string",
"description": "Second parameter"
}
},
"required": [
"param1",
"param2"
]
}
}
]
Example function tool call syntax:
<｜tool▁calls▁begin｜><｜tool▁call▁begin｜>function<｜tool▁sep｜>example_function_name
```json
{
"arg1": "some_value"
...
}
```
<｜tool▁call▁end｜><｜tool▁calls▁end｜>
<｜User｜>Hello, please help me.<｜end▁of▁sentence｜><｜Assistant｜><｜tool▁calls▁begin｜><｜tool▁call▁begin｜>function<｜tool▁sep｜>test_function_name
```json
{"param1":0x6414d8'
Common Suffix: '0}
```<｜tool▁call▁end｜><｜tool▁calls▁end｜><｜end▁of▁sentence｜>'
Left (difference): 'b09420, "param2":0x6414d8ac46a'
Right (difference): 'ac1290, "param2":0x6414d8ab6cd0}
```<｜tool▁call▁end｜>
<｜tool▁call▁begin｜>function<｜tool▁sep｜>test_function_name
```json
{"param1":0x6414d8b17be0, "param2":0x6414d8ae5f2'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: 'You can call any of the following function tools to satisfy the user's requests: [
{
"name": "test_function_name",
"description": "A test function for debugging",
"parameters": {
"type": "object",
"properties": {
"param1": {
"type": "string",
"description": "First parameter"
},
"param2": {
"type": "string",
"description": "Second parameter"
}
},
"required": [
"param1",
"param2"
]
}
}
]
Example function tool call syntax:
<｜tool▁calls▁begin｜><｜tool▁call▁begin｜>function<｜tool▁sep｜>example_function_name
```json
{
"arg1": "some_value"
...
}
```
<｜tool▁call▁end｜><｜tool▁calls▁end｜>
<｜User｜>Hello, please help me.<｜end▁of▁sentence｜><｜Assistant｜><｜tool▁calls▁begin｜><｜tool▁call▁begin｜>function<｜tool▁sep｜>test_function_name
```json
{"param1":0x6414d8'
Common Suffix: '0}
```<｜tool▁call▁end｜><｜tool▁calls▁end｜><｜end▁of▁sentence｜><｜User｜>Continue.<｜end▁of▁sentence｜>'
Left (difference): 'ac2c10, "param2":0x6414d8aba63'
Right (difference): 'b06690, "param2":0x6414d8ab6cd0}
```<｜tool▁call▁end｜>
<｜tool▁call▁begin｜>function<｜tool▁sep｜>test_function_name
```json
{"param1":0x6414d8aba960, "param2":0x6414d8aba0e'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: 'You can call any of the following function tools to satisfy the user's requests: [
{
"name": "test_function_name",
"description": "A test function for debugging",
"parameters": {
"type": "object",
"properties": {
"param1": {
"type": "string",
"description": "First parameter"
},
"param2": {
"type": "string",
"description": "Second parameter"
}
},
"required": [
"param1",
"param2"
]
}
}
]
Example function tool call syntax:
<｜tool▁calls▁begin｜><｜tool▁call▁begin｜>function<｜tool▁sep｜>example_function_name
```json
{
"arg1": "some_value"
...
}
```
<｜tool▁call▁end｜><｜tool▁calls▁end｜>
<｜User｜>Hello, please help me.<｜end▁of▁sentence｜><｜Assistant｜><｜tool▁calls▁begin｜><｜tool▁call▁begin｜>function<｜tool▁sep｜>test_function_name
```json
{"param1":0x6414d8'
Common Suffix: '0}
```<｜tool▁call▁end｜><｜tool▁calls▁end｜><｜end▁of▁sentence｜>'
Left (difference): 'abf070, "param2":0x6414d8aba63'
Right (difference): 'b09420, "param2":0x6414d8b17be'
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/meetkai-functionary-medium-v3.1.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: true
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Cutting Knowledge Date: December 2023
'
Common Suffix: '<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|>'
Left (difference): ''
Right (difference): '
You have access to the following functions:
Use the function 'test_function_name' to 'A test function for debugging'
{"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}
Think very carefully before calling functions.
If a you choose to call a function ONLY reply in the following format:
<{start_tag}={function_name}>{parameters}{end_tag}
where
start_tag => `<function`
parameters => a JSON dict with the function argument name as key and function argument value as value.
end_tag => `</function>`
Here is an example,
<function=example_function_name>{"example_name": "example_value"}</function>
Reminder:
- If looking for real time information use relevant functions before falling back to brave_search
- Function calls MUST follow the specified format, start with <function= and end with </function>
- Required parameters MUST be specified
- Only call one function at a time
- Put the entire function call reply on one line
'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Cutting Knowledge Date: December 2023
<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|>'
Common Suffix: ''
Left (difference): ''
Right (difference): '<|start_header_id|>assistant<|end_header_id|>
'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Cutting Knowledge Date: December 2023
<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
I can help you with that.<|eot_id|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Cutting Knowledge Date: December 2023
<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
I can help you with that.<|eot_id|><|start_header_id|>user<|end_header_id|>
Thank you.<|eot_id|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Cutting Knowledge Date: December 2023
You have access to the following functions:
Use the function 'test_function_name' to 'A test function for debugging'
{"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}
Think very carefully before calling functions.
If a you choose to call a function ONLY reply in the following format:
<{start_tag}={function_name}>{parameters}{end_tag}
where
start_tag => `<function`
parameters => a JSON dict with the function argument name as key and function argument value as value.
end_tag => `</function>`
Here is an example,
<function=example_function_name>{"example_name": "example_value"}</function>
Reminder:
- If looking for real time information use relevant functions before falling back to brave_search
- Function calls MUST follow the specified format, start with <function= and end with </function>
- Required parameters MUST be specified
- Only call one function at a time
- Put the entire function call reply on one line
<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
'
Common Suffix: ''
Left (difference): 'Let me help you.<|eot_id|>'
Right (difference): '<function=test_function_name>{"param1":0x6414d8ae7330, "param2":0x6414d8aaf400}</function><|eom_id|>'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Cutting Knowledge Date: December 2023
You have access to the following functions:
Use the function 'test_function_name' to 'A test function for debugging'
{"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}
Think very carefully before calling functions.
If a you choose to call a function ONLY reply in the following format:
<{start_tag}={function_name}>{parameters}{end_tag}
where
start_tag => `<function`
parameters => a JSON dict with the function argument name as key and function argument value as value.
end_tag => `</function>`
Here is an example,
<function=example_function_name>{"example_name": "example_value"}</function>
Reminder:
- If looking for real time information use relevant functions before falling back to brave_search
- Function calls MUST follow the specified format, start with <function= and end with </function>
- Required parameters MUST be specified
- Only call one function at a time
- Put the entire function call reply on one line
<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
'
Common Suffix: '<|start_header_id|>user<|end_header_id|>
Continue.<|eot_id|>'
Left (difference): 'Let me help you.<|eot_id|>'
Right (difference): '<function=test_function_name>{"param1":0x6414d8ac1f50, "param2":0x6414d8aba630}</function><|eom_id|>'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Cutting Knowledge Date: December 2023
You have access to the following functions:
Use the function 'test_function_name' to 'A test function for debugging'
{"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}
Think very carefully before calling functions.
If a you choose to call a function ONLY reply in the following format:
<{start_tag}={function_name}>{parameters}{end_tag}
where
start_tag => `<function`
parameters => a JSON dict with the function argument name as key and function argument value as value.
end_tag => `</function>`
Here is an example,
<function=example_function_name>{"example_name": "example_value"}</function>
Reminder:
- If looking for real time information use relevant functions before falling back to brave_search
- Function calls MUST follow the specified format, start with <function= and end with </function>
- Required parameters MUST be specified
- Only call one function at a time
- Put the entire function call reply on one line
<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
<function=test_function_name>{"param1":0x6414d8ab'
Common Suffix: '0}</function><|eom_id|>'
Left (difference): '7aa0, "param2":0x6414d8abb62'
Right (difference): '62f0, "param2":0x6414d8aba410}</function><function=test_function_name>{"param1":0x6414d8ac5360, "param2":0x6414d8b05ef'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Cutting Knowledge Date: December 2023
You have access to the following functions:
Use the function 'test_function_name' to 'A test function for debugging'
{"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}
Think very carefully before calling functions.
If a you choose to call a function ONLY reply in the following format:
<{start_tag}={function_name}>{parameters}{end_tag}
where
start_tag => `<function`
parameters => a JSON dict with the function argument name as key and function argument value as value.
end_tag => `</function>`
Here is an example,
<function=example_function_name>{"example_name": "example_value"}</function>
Reminder:
- If looking for real time information use relevant functions before falling back to brave_search
- Function calls MUST follow the specified format, start with <function= and end with </function>
- Required parameters MUST be specified
- Only call one function at a time
- Put the entire function call reply on one line
<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
<function=test_function_name>{"param1":0x6414d8ab'
Common Suffix: '0}</function><|eom_id|><|start_header_id|>user<|end_header_id|>
Continue.<|eot_id|>'
Left (difference): '9420, "param2":0x6414d8ae027'
Right (difference): 'e5f0, "param2":0x6414d8b24fa0}</function><function=test_function_name>{"param1":0x6414d8ab7000, "param2":0x6414d8ac492'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Cutting Knowledge Date: December 2023
You have access to the following functions:
Use the function 'test_function_name' to 'A test function for debugging'
{"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}
Think very carefully before calling functions.
If a you choose to call a function ONLY reply in the following format:
<{start_tag}={function_name}>{parameters}{end_tag}
where
start_tag => `<function`
parameters => a JSON dict with the function argument name as key and function argument value as value.
end_tag => `</function>`
Here is an example,
<function=example_function_name>{"example_name": "example_value"}</function>
Reminder:
- If looking for real time information use relevant functions before falling back to brave_search
- Function calls MUST follow the specified format, start with <function= and end with </function>
- Required parameters MUST be specified
- Only call one function at a time
- Put the entire function call reply on one line
<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
<function=test_function_name>{"param1":0x6414d8ac'
Common Suffix: '0}</function><|eom_id|>'
Left (difference): 'b270, "param2":0x6414d8abf80'
Right (difference): '1290, "param2":0x6414d8abaeb'
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/meetkai-functionary-medium-v3.2.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: true
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
You are capable of executing available function(s) if required.
Only execute function(s) when absolutely necessary.
Ask for the required input to:recipient==all
Use JSON for function arguments.
Respond in this format:
>>>${recipient}
${content}
Available functions:
// Supported function definitions that should be called when necessary.
namespace functions {
'
Common Suffix: '} // namespace functions<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|>'
Left (difference): ''
Right (difference): '// A test function for debugging
type test_function_name = (_: {
// First parameter.
param1: string,
// Second parameter.
param2: string,
}) => any;
'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
You are capable of executing available function(s) if required.
Only execute function(s) when absolutely necessary.
Ask for the required input to:recipient==all
Use JSON for function arguments.
Respond in this format:
>>>${recipient}
${content}
Available functions:
// Supported function definitions that should be called when necessary.
namespace functions {
} // namespace functions<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|>'
Common Suffix: ''
Left (difference): ''
Right (difference): '<|start_header_id|>assistant<|end_header_id|>
>>>'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
You are capable of executing available function(s) if required.
Only execute function(s) when absolutely necessary.
Ask for the required input to:recipient==all
Use JSON for function arguments.
Respond in this format:
>>>${recipient}
${content}
Available functions:
// Supported function definitions that should be called when necessary.
namespace functions {
} // namespace functions<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
>>>all
I can help you with that.<|eot_id|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
You are capable of executing available function(s) if required.
Only execute function(s) when absolutely necessary.
Ask for the required input to:recipient==all
Use JSON for function arguments.
Respond in this format:
>>>${recipient}
${content}
Available functions:
// Supported function definitions that should be called when necessary.
namespace functions {
} // namespace functions<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
>>>all
I can help you with that.<|eot_id|><|start_header_id|>user<|end_header_id|>
Thank you.<|eot_id|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
You are capable of executing available function(s) if required.
Only execute function(s) when absolutely necessary.
Ask for the required input to:recipient==all
Use JSON for function arguments.
Respond in this format:
>>>${recipient}
${content}
Available functions:
// Supported function definitions that should be called when necessary.
namespace functions {
// A test function for debugging
type test_function_name = (_: {
// First parameter.
param1: string,
// Second parameter.
param2: string,
}) => any;
} // namespace functions<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
>>>'
Common Suffix: '<|eot_id|>'
Left (difference): 'all
Let me help you.'
Right (difference): 'test_function_name
{"param1":0x6414d8af9280, "param2":0x6414d8af8a90}'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
You are capable of executing available function(s) if required.
Only execute function(s) when absolutely necessary.
Ask for the required input to:recipient==all
Use JSON for function arguments.
Respond in this format:
>>>${recipient}
${content}
Available functions:
// Supported function definitions that should be called when necessary.
namespace functions {
// A test function for debugging
type test_function_name = (_: {
// First parameter.
param1: string,
// Second parameter.
param2: string,
}) => any;
} // namespace functions<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
>>>'
Common Suffix: '<|eot_id|><|start_header_id|>user<|end_header_id|>
Continue.<|eot_id|>'
Left (difference): 'all
Let me help you.'
Right (difference): 'test_function_name
{"param1":0x6414d8ae3c80, "param2":0x6414d8b39240}'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
You are capable of executing available function(s) if required.
Only execute function(s) when absolutely necessary.
Ask for the required input to:recipient==all
Use JSON for function arguments.
Respond in this format:
>>>${recipient}
${content}
Available functions:
// Supported function definitions that should be called when necessary.
namespace functions {
// A test function for debugging
type test_function_name = (_: {
// First parameter.
param1: string,
// Second parameter.
param2: string,
}) => any;
} // namespace functions<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
>>>test_function_name
{"param1":0x6414d8afff80, "param2":0x6414d8b3'
Common Suffix: '0}<|eot_id|>'
Left (difference): 'de2'
Right (difference): 'e8b0}>>>test_function_name
{"param1":0x6414d8ad7ff0, "param2":0x6414d8ae3c8'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
You are capable of executing available function(s) if required.
Only execute function(s) when absolutely necessary.
Ask for the required input to:recipient==all
Use JSON for function arguments.
Respond in this format:
>>>${recipient}
${content}
Available functions:
// Supported function definitions that should be called when necessary.
namespace functions {
// A test function for debugging
type test_function_name = (_: {
// First parameter.
param1: string,
// Second parameter.
param2: string,
}) => any;
} // namespace functions<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
>>>test_function_name
{"param1":0x6414d8a'
Common Suffix: '0}<|eot_id|><|start_header_id|>user<|end_header_id|>
Continue.<|eot_id|>'
Left (difference): 'e4d40, "param2":0x6414d8abf04'
Right (difference): 'b5ac0, "param2":0x6414d8b3e8b0}>>>test_function_name
{"param1":0x6414d8b210c0, "param2":0x6414d8b0e31'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
You are capable of executing available function(s) if required.
Only execute function(s) when absolutely necessary.
Ask for the required input to:recipient==all
Use JSON for function arguments.
Respond in this format:
>>>${recipient}
${content}
Available functions:
// Supported function definitions that should be called when necessary.
namespace functions {
// A test function for debugging
type test_function_name = (_: {
// First parameter.
param1: string,
// Second parameter.
param2: string,
}) => any;
} // namespace functions<|eot_id|><|start_header_id|>user<|end_header_id|>
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
>>>test_function_name
{"param1":0x6414d8a'
Common Suffix: '0}<|eot_id|>'
Left (difference): 'ba960, "param2":0x6414d8ab9ca'
Right (difference): 'c4bf0, "param2":0x6414d8ae4d4'
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/meta-llama-Llama-3.1-8B-Instruct.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: false
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Environment: ipython
Cutting Knowledge Date: December 2023
Today Date: 26 Jul 2024
<|eot_id|><|start_header_id|>user<|end_header_id|>
Given the following functions, please respond with a JSON for a function call with its proper arguments that best answers the given prompt.
Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.Do not use variables.
'
Common Suffix: 'Hello, please help me.<|eot_id|>'
Left (difference): ''
Right (difference): '{
"type": "function",
"function": {
"name": "test_function_name",
"description": "A test function for debugging",
"parameters": {
"type": "object",
"properties": {
"param1": {
"type": "string",
"description": "First parameter"
},
"param2": {
"type": "string",
"description": "Second parameter"
}
},
"required": [
"param1",
"param2"
]
}
}
}
'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Environment: ipython
Cutting Knowledge Date: December 2023
Today Date: 26 Jul 2024
<|eot_id|><|start_header_id|>user<|end_header_id|>
Given the following functions, please respond with a JSON for a function call with its proper arguments that best answers the given prompt.
Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.Do not use variables.
Hello, please help me.<|eot_id|>'
Common Suffix: ''
Left (difference): ''
Right (difference): '<|start_header_id|>assistant<|end_header_id|>
'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Environment: ipython
Cutting Knowledge Date: December 2023
Today Date: 26 Jul 2024
<|eot_id|><|start_header_id|>user<|end_header_id|>
Given the following functions, please respond with a JSON for a function call with its proper arguments that best answers the given prompt.
Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.Do not use variables.
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
I can help you with that.<|eot_id|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Environment: ipython
Cutting Knowledge Date: December 2023
Today Date: 26 Jul 2024
<|eot_id|><|start_header_id|>user<|end_header_id|>
Given the following functions, please respond with a JSON for a function call with its proper arguments that best answers the given prompt.
Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.Do not use variables.
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
I can help you with that.<|eot_id|><|start_header_id|>user<|end_header_id|>
Thank you.<|eot_id|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Environment: ipython
Cutting Knowledge Date: December 2023
Today Date: 26 Jul 2024
<|eot_id|><|start_header_id|>user<|end_header_id|>
Given the following functions, please respond with a JSON for a function call with its proper arguments that best answers the given prompt.
Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.Do not use variables.
{
"type": "function",
"function": {
"name": "test_function_name",
"description": "A test function for debugging",
"parameters": {
"type": "object",
"properties": {
"param1": {
"type": "string",
"description": "First parameter"
},
"param2": {
"type": "string",
"description": "Second parameter"
}
},
"required": [
"param1",
"param2"
]
}
}
}
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
'
Common Suffix: '<|eot_id|>'
Left (difference): 'Let me help you.'
Right (difference): '{"name": "test_function_name", "parameters": {"param1": "value1", "param2": "value2"}}'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Environment: ipython
Cutting Knowledge Date: December 2023
Today Date: 26 Jul 2024
<|eot_id|><|start_header_id|>user<|end_header_id|>
Given the following functions, please respond with a JSON for a function call with its proper arguments that best answers the given prompt.
Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.Do not use variables.
{
"type": "function",
"function": {
"name": "test_function_name",
"description": "A test function for debugging",
"parameters": {
"type": "object",
"properties": {
"param1": {
"type": "string",
"description": "First parameter"
},
"param2": {
"type": "string",
"description": "Second parameter"
}
},
"required": [
"param1",
"param2"
]
}
}
}
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
'
Common Suffix: '<|eot_id|><|start_header_id|>user<|end_header_id|>
Continue.<|eot_id|>'
Left (difference): 'Let me help you.'
Right (difference): '{"name": "test_function_name", "parameters": {"param1": "value1", "param2": "value2"}}'
Analysis failed:
------------
While executing CallExpression at line 71, column 32 in source:
... == 1 %}↵ {{- raise_exception("This model only supports single tool-c...
^
Error: Jinja Exception: This model only supports single tool-calls at once!
================================================================================
ANALYZING TEMPLATE: models/templates/meta-llama-Llama-3.2-3B-Instruct.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: false
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Environment: ipython
Cutting Knowledge Date: December 2023
Today Date: 26 Jan 2026
<|eot_id|><|start_header_id|>user<|end_header_id|>
Given the following functions, please respond with a JSON for a function call with its proper arguments that best answers the given prompt.
Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.Do not use variables.
'
Common Suffix: 'Hello, please help me.<|eot_id|>'
Left (difference): ''
Right (difference): '{
"type": "function",
"function": {
"name": "test_function_name",
"description": "A test function for debugging",
"parameters": {
"type": "object",
"properties": {
"param1": {
"type": "string",
"description": "First parameter"
},
"param2": {
"type": "string",
"description": "Second parameter"
}
},
"required": [
"param1",
"param2"
]
}
}
}
'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Environment: ipython
Cutting Knowledge Date: December 2023
Today Date: 26 Jan 2026
<|eot_id|><|start_header_id|>user<|end_header_id|>
Given the following functions, please respond with a JSON for a function call with its proper arguments that best answers the given prompt.
Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.Do not use variables.
Hello, please help me.<|eot_id|>'
Common Suffix: ''
Left (difference): ''
Right (difference): '<|start_header_id|>assistant<|end_header_id|>
'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Environment: ipython
Cutting Knowledge Date: December 2023
Today Date: 26 Jan 2026
<|eot_id|><|start_header_id|>user<|end_header_id|>
Given the following functions, please respond with a JSON for a function call with its proper arguments that best answers the given prompt.
Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.Do not use variables.
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
I can help you with that.<|eot_id|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Environment: ipython
Cutting Knowledge Date: December 2023
Today Date: 26 Jan 2026
<|eot_id|><|start_header_id|>user<|end_header_id|>
Given the following functions, please respond with a JSON for a function call with its proper arguments that best answers the given prompt.
Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.Do not use variables.
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
I can help you with that.<|eot_id|><|start_header_id|>user<|end_header_id|>
Thank you.<|eot_id|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Environment: ipython
Cutting Knowledge Date: December 2023
Today Date: 26 Jan 2026
<|eot_id|><|start_header_id|>user<|end_header_id|>
Given the following functions, please respond with a JSON for a function call with its proper arguments that best answers the given prompt.
Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.Do not use variables.
{
"type": "function",
"function": {
"name": "test_function_name",
"description": "A test function for debugging",
"parameters": {
"type": "object",
"properties": {
"param1": {
"type": "string",
"description": "First parameter"
},
"param2": {
"type": "string",
"description": "Second parameter"
}
},
"required": [
"param1",
"param2"
]
}
}
}
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
'
Common Suffix: '<|eot_id|>'
Left (difference): 'Let me help you.'
Right (difference): '{"name": "test_function_name", "parameters": {"param1": "value1", "param2": "value2"}}'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Environment: ipython
Cutting Knowledge Date: December 2023
Today Date: 26 Jan 2026
<|eot_id|><|start_header_id|>user<|end_header_id|>
Given the following functions, please respond with a JSON for a function call with its proper arguments that best answers the given prompt.
Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.Do not use variables.
{
"type": "function",
"function": {
"name": "test_function_name",
"description": "A test function for debugging",
"parameters": {
"type": "object",
"properties": {
"param1": {
"type": "string",
"description": "First parameter"
},
"param2": {
"type": "string",
"description": "Second parameter"
}
},
"required": [
"param1",
"param2"
]
}
}
}
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
'
Common Suffix: '<|eot_id|><|start_header_id|>user<|end_header_id|>
Continue.<|eot_id|>'
Left (difference): 'Let me help you.'
Right (difference): '{"name": "test_function_name", "parameters": {"param1": "value1", "param2": "value2"}}'
Analysis failed:
------------
While executing CallExpression at line 72, column 32 in source:
... == 1 %}↵ {{- raise_exception("This model only supports single tool-c...
^
Error: Jinja Exception: This model only supports single tool-calls at once!
================================================================================
ANALYZING TEMPLATE: models/templates/meta-llama-Llama-3.3-70B-Instruct.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: false
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Environment: ipython
Cutting Knowledge Date: December 2023
Today Date: 26 Jul 2024
<|eot_id|><|start_header_id|>user<|end_header_id|>
Given the following functions, please respond with a JSON for a function call with its proper arguments that best answers the given prompt.
Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.Do not use variables.
'
Common Suffix: 'Hello, please help me.<|eot_id|>'
Left (difference): ''
Right (difference): '{
"type": "function",
"function": {
"name": "test_function_name",
"description": "A test function for debugging",
"parameters": {
"type": "object",
"properties": {
"param1": {
"type": "string",
"description": "First parameter"
},
"param2": {
"type": "string",
"description": "Second parameter"
}
},
"required": [
"param1",
"param2"
]
}
}
}
'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Environment: ipython
Cutting Knowledge Date: December 2023
Today Date: 26 Jul 2024
<|eot_id|><|start_header_id|>user<|end_header_id|>
Given the following functions, please respond with a JSON for a function call with its proper arguments that best answers the given prompt.
Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.Do not use variables.
Hello, please help me.<|eot_id|>'
Common Suffix: ''
Left (difference): ''
Right (difference): '<|start_header_id|>assistant<|end_header_id|>
'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Environment: ipython
Cutting Knowledge Date: December 2023
Today Date: 26 Jul 2024
<|eot_id|><|start_header_id|>user<|end_header_id|>
Given the following functions, please respond with a JSON for a function call with its proper arguments that best answers the given prompt.
Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.Do not use variables.
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
I can help you with that.<|eot_id|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Environment: ipython
Cutting Knowledge Date: December 2023
Today Date: 26 Jul 2024
<|eot_id|><|start_header_id|>user<|end_header_id|>
Given the following functions, please respond with a JSON for a function call with its proper arguments that best answers the given prompt.
Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.Do not use variables.
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
I can help you with that.<|eot_id|><|start_header_id|>user<|end_header_id|>
Thank you.<|eot_id|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Environment: ipython
Cutting Knowledge Date: December 2023
Today Date: 26 Jul 2024
<|eot_id|><|start_header_id|>user<|end_header_id|>
Given the following functions, please respond with a JSON for a function call with its proper arguments that best answers the given prompt.
Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.Do not use variables.
{
"type": "function",
"function": {
"name": "test_function_name",
"description": "A test function for debugging",
"parameters": {
"type": "object",
"properties": {
"param1": {
"type": "string",
"description": "First parameter"
},
"param2": {
"type": "string",
"description": "Second parameter"
}
},
"required": [
"param1",
"param2"
]
}
}
}
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
'
Common Suffix: '<|eot_id|>'
Left (difference): 'Let me help you.'
Right (difference): '{"name": "test_function_name", "parameters": {"param1": "value1", "param2": "value2"}}'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<|start_header_id|>system<|end_header_id|>
Environment: ipython
Cutting Knowledge Date: December 2023
Today Date: 26 Jul 2024
<|eot_id|><|start_header_id|>user<|end_header_id|>
Given the following functions, please respond with a JSON for a function call with its proper arguments that best answers the given prompt.
Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.Do not use variables.
{
"type": "function",
"function": {
"name": "test_function_name",
"description": "A test function for debugging",
"parameters": {
"type": "object",
"properties": {
"param1": {
"type": "string",
"description": "First parameter"
},
"param2": {
"type": "string",
"description": "Second parameter"
}
},
"required": [
"param1",
"param2"
]
}
}
}
Hello, please help me.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
'
Common Suffix: '<|eot_id|><|start_header_id|>user<|end_header_id|>
Continue.<|eot_id|>'
Left (difference): 'Let me help you.'
Right (difference): '{"name": "test_function_name", "parameters": {"param1": "value1", "param2": "value2"}}'
Analysis failed:
------------
While executing CallExpression at line 71, column 32 in source:
... == 1 %}↵ {{- raise_exception("This model only supports single tool-c...
^
Error: Jinja Exception: This model only supports single tool-calls at once!
================================================================================
ANALYZING TEMPLATE: models/templates/mistralai-Ministral-3-14B-Reasoning-2512.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: false
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '[SYSTEM_PROMPT]# HOW YOU SHOULD THINK AND ANSWER
First draft your thinking process (inner monologue) until you arrive at a response. Format your response using Markdown, and use LaTeX for any mathematical equations. Write both your thoughts and the response in the same language as the input.
Your thinking process must follow the template below:[THINK]Your thoughts or/and draft, like working through an exercise on scratch paper. Be as casual and as long as you want until you are confident to generate the response to the user.[/THINK]Here, provide a self-contained response.[/SYSTEM_PROMPT]'
Common Suffix: '[INST]Hello, please help me.[/INST]'
Left (difference): ''
Right (difference): '[AVAILABLE_TOOLS][{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}][/AVAILABLE_TOOLS]'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '[SYSTEM_PROMPT]# HOW YOU SHOULD THINK AND ANSWER
First draft your thinking process (inner monologue) until you arrive at a response. Format your response using Markdown, and use LaTeX for any mathematical equations. Write both your thoughts and the response in the same language as the input.
Your thinking process must follow the template below:[THINK]Your thoughts or/and draft, like working through an exercise on scratch paper. Be as casual and as long as you want until you are confident to generate the response to the user.[/THINK]Here, provide a self-contained response.[/SYSTEM_PROMPT][INST]Hello, please help me.[/INST]'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '[SYSTEM_PROMPT]# HOW YOU SHOULD THINK AND ANSWER
First draft your thinking process (inner monologue) until you arrive at a response. Format your response using Markdown, and use LaTeX for any mathematical equations. Write both your thoughts and the response in the same language as the input.
Your thinking process must follow the template below:[THINK]Your thoughts or/and draft, like working through an exercise on scratch paper. Be as casual and as long as you want until you are confident to generate the response to the user.[/THINK]Here, provide a self-contained response.[/SYSTEM_PROMPT][INST]Hello, please help me.[/INST]I can help you with that.'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '[SYSTEM_PROMPT]# HOW YOU SHOULD THINK AND ANSWER
First draft your thinking process (inner monologue) until you arrive at a response. Format your response using Markdown, and use LaTeX for any mathematical equations. Write both your thoughts and the response in the same language as the input.
Your thinking process must follow the template below:[THINK]Your thoughts or/and draft, like working through an exercise on scratch paper. Be as casual and as long as you want until you are confident to generate the response to the user.[/THINK]Here, provide a self-contained response.[/SYSTEM_PROMPT][INST]Hello, please help me.[/INST]I can help you with that.[INST]Thank you.[/INST]'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
Analysis failed:
------------
While executing FilterExpression at line 90, column 37 in source:
... }}↵ {%- elif message['content'] | length > 0 %}↵ {%- for bloc...
^
Error: Unknown (built-in) filter 'length' for type None
================================================================================
ANALYZING TEMPLATE: models/templates/mistralai-Mistral-Nemo-Instruct-2407.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: false
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '[INST]Hello, please help me.[/INST]'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '[INST]Hello, please help me.[/INST]'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '[INST]Hello, please help me.[/INST]I can help you with that.'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '[INST]Hello, please help me.[/INST]I can help you with that.[INST]Thank you.[/INST]'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
Analysis failed:
------------
While executing CallExpression at line 62, column 36 in source:
...9 %}↵ {{- raise_exception("Tool call IDs should be alphanumeric s...
^
Error: Jinja Exception: Tool call IDs should be alphanumeric strings with length 9!
================================================================================
ANALYZING TEMPLATE: models/templates/moonshotai-Kimi-K2.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<|im_system|>'
Common Suffix: 'system<|im_middle|>You are a helpful assistant<|im_end|><|im_user|>user<|im_middle|>Hello, please help me.<|im_end|>'
Left (difference): ''
Right (difference): 'tool_declare<|im_middle|>[{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}]<|im_end|><|im_system|>'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<|im_system|>system<|im_middle|>You are a helpful assistant<|im_end|><|im_user|>user<|im_middle|>Hello, please help me.<|im_end|>'
Common Suffix: ''
Left (difference): ''
Right (difference): '<|im_assistant|>assistant<|im_middle|>'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<|im_system|>system<|im_middle|>You are a helpful assistant<|im_end|><|im_user|>user<|im_middle|>Hello, please help me.<|im_end|><|im_assistant|>assistant<|im_middle|>I can help you with that.<|im_end|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<|im_system|>system<|im_middle|>You are a helpful assistant<|im_end|><|im_user|>user<|im_middle|>Hello, please help me.<|im_end|><|im_assistant|>assistant<|im_middle|>I can help you with that.<|im_end|><|im_user|>user<|im_middle|>Thank you.<|im_end|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<|im_system|>tool_declare<|im_middle|>[{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}]<|im_end|><|im_system|>system<|im_middle|>You are a helpful assistant<|im_end|><|im_user|>user<|im_middle|>Hello, please help me.<|im_end|><|im_assistant|>assistant<|im_middle|>'
Common Suffix: '<|im_end|>'
Left (difference): 'Let me help you.'
Right (difference): '<|tool_calls_section_begin|><|tool_call_begin|>functions.test_function_name:0<|tool_call_argument_begin|>{"param1": "value1", "param2": "value2"}<|tool_call_end|><|tool_calls_section_end|>'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<|im_system|>tool_declare<|im_middle|>[{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}]<|im_end|><|im_system|>system<|im_middle|>You are a helpful assistant<|im_end|><|im_user|>user<|im_middle|>Hello, please help me.<|im_end|><|im_assistant|>assistant<|im_middle|>'
Common Suffix: '<|im_end|><|im_user|>user<|im_middle|>Continue.<|im_end|>'
Left (difference): 'Let me help you.'
Right (difference): '<|tool_calls_section_begin|><|tool_call_begin|>functions.test_function_name:0<|tool_call_argument_begin|>{"param1": "value1", "param2": "value2"}<|tool_call_end|><|tool_calls_section_end|>'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '<|im_system|>tool_declare<|im_middle|>[{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}]<|im_end|><|im_system|>system<|im_middle|>You are a helpful assistant<|im_end|><|im_user|>user<|im_middle|>Hello, please help me.<|im_end|><|im_assistant|>assistant<|im_middle|><|tool_calls_section_begin|><|tool_call_begin|>functions.test_function_name:0<|tool_call_argument_begin|>{"param1": "value1", "param2": "value2"}<|tool_call_end|>'
Common Suffix: '<|tool_calls_section_end|><|im_end|>'
Left (difference): ''
Right (difference): '<|tool_call_begin|>functions.test_function_name:1<|tool_call_argument_begin|>{"param1": "value3", "param2": "value4"}<|tool_call_end|>'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '<|im_system|>tool_declare<|im_middle|>[{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}]<|im_end|><|im_system|>system<|im_middle|>You are a helpful assistant<|im_end|><|im_user|>user<|im_middle|>Hello, please help me.<|im_end|><|im_assistant|>assistant<|im_middle|><|tool_calls_section_begin|><|tool_call_begin|>functions.test_function_name:0<|tool_call_argument_begin|>{"param1": "value1", "param2": "value2"}<|tool_call_end|>'
Common Suffix: '<|tool_calls_section_end|><|im_end|><|im_user|>user<|im_middle|>Continue.<|im_end|>'
Left (difference): ''
Right (difference): '<|tool_call_begin|>functions.test_function_name:1<|tool_call_argument_begin|>{"param1": "value3", "param2": "value4"}<|tool_call_end|>'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '<|im_system|>tool_declare<|im_middle|>[{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}]<|im_end|><|im_system|>system<|im_middle|>You are a helpful assistant<|im_end|><|im_user|>user<|im_middle|>Hello, please help me.<|im_end|><|im_assistant|>assistant<|im_middle|><|tool_calls_section_begin|><|tool_call_begin|>functions.test_function_name:0<|tool_call_argument_begin|>{"param1": "value1", "param2": "value2"}<|tool_call_end|><|tool_calls_section_end|><|im_end|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/openai-gpt-oss-120b.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: true
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: false
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<|start|>system<|message|>You are ChatGPT, a large language model trained by OpenAI.
Knowledge cutoff: 2024-06
Current date: 2026-01-26
Reasoning: medium
# Valid channels: analysis, commentary, final. Channel must be included for every message.'
Common Suffix: '<|end|><|start|>user<|message|>Hello, please help me.<|end|>'
Left (difference): ''
Right (difference): '
Calls to these tools must go to the commentary channel: 'functions'.<|end|><|start|>developer<|message|># Tools
## functions
namespace functions {
// A test function for debugging
type test_function_name = (_: {
// First parameter
param1: string,
// Second parameter
param2: string,
}) => any;
} // namespace functions'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<|start|>system<|message|>You are ChatGPT, a large language model trained by OpenAI.
Knowledge cutoff: 2024-06
Current date: 2026-01-26
Reasoning: medium
# Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|><|start|>user<|message|>Hello, please help me.<|end|>'
Common Suffix: ''
Left (difference): ''
Right (difference): '<|start|>assistant'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<|start|>system<|message|>You are ChatGPT, a large language model trained by OpenAI.
Knowledge cutoff: 2024-06
Current date: 2026-01-26
Reasoning: medium
# Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|><|start|>user<|message|>Hello, please help me.<|end|><|start|>assistant<|channel|>final<|message|>I can help you with that.<|return|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<|start|>system<|message|>You are ChatGPT, a large language model trained by OpenAI.
Knowledge cutoff: 2024-06
Current date: 2026-01-26
Reasoning: medium
# Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|><|start|>user<|message|>Hello, please help me.<|end|><|start|>assistant<|channel|>final<|message|>I can help you with that.<|end|><|start|>user<|message|>Thank you.<|end|>'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
Analysis failed:
------------
While executing BinaryExpression at line 264, column 53 in source:
...{%- if "<|channel|>analysis<|message|>" in message.content or "<|channel|>final<...
^
Error: Cannot perform operation on null values
================================================================================
ANALYZING TEMPLATE: models/templates/unsloth-Apriel-1.5.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '<|system|>
You are a thoughtful and systematic AI assistant built by ServiceNow Language Models (SLAM) lab. Before providing an answer, analyze the problem carefully and present your reasoning step by step. After explaining your thought process, provide the final solution in the following format: [BEGIN FINAL RESPONSE] ... [END FINAL RESPONSE].'
Common Suffix: '
<|end|>
<|user|>
Hello, please help me.
<|end|>
'
Left (difference): ''
Right (difference): 'You are provided with function signatures within <available_tools></available_tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about the arguments. You should infer the argument values from previous user responses and the system message. Here are the available tools:
<available_tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</available_tools>
Return all function calls as a list of json objects within <tool_call></tool_call> XML tags. Each json object should contain a function name and arguments as follows:
<tool_calls>[{"name": <function-name-1>, "arguments": <args-dict-1>}, {"name": <function-name-2>, "arguments": <args-dict-2>},...]</tool_calls>
<|end|>
<|system|>
You are a thoughtful and systematic AI assistant built by ServiceNow Language Models (SLAM) lab. Before providing an answer, analyze the problem carefully and present your reasoning step by step. After explaining your thought process, provide the final solution in the following format: [BEGIN FINAL RESPONSE] ... [END FINAL RESPONSE].'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '<|system|>
You are a thoughtful and systematic AI assistant built by ServiceNow Language Models (SLAM) lab. Before providing an answer, analyze the problem carefully and present your reasoning step by step. After explaining your thought process, provide the final solution in the following format: [BEGIN FINAL RESPONSE] ... [END FINAL RESPONSE].
<|end|>
<|user|>
Hello, please help me.
<|end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): '<|assistant|>
'
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '<|system|>
You are a thoughtful and systematic AI assistant built by ServiceNow Language Models (SLAM) lab. Before providing an answer, analyze the problem carefully and present your reasoning step by step. After explaining your thought process, provide the final solution in the following format: [BEGIN FINAL RESPONSE] ... [END FINAL RESPONSE].
<|end|>
<|user|>
Hello, please help me.
<|end|>
<|assistant|>
I can help you with that.
<|end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '<|system|>
You are a thoughtful and systematic AI assistant built by ServiceNow Language Models (SLAM) lab. Before providing an answer, analyze the problem carefully and present your reasoning step by step. After explaining your thought process, provide the final solution in the following format: [BEGIN FINAL RESPONSE] ... [END FINAL RESPONSE].
<|end|>
<|user|>
Hello, please help me.
<|end|>
<|assistant|>
I can help you with that.
<|end|>
<|user|>
Thank you.
<|end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without tool call (user, assistant) ===
Common Prefix: '<|system|>
You are a thoughtful and systematic AI assistant built by ServiceNow Language Models (SLAM) lab. Before providing an answer, analyze the problem carefully and present your reasoning step by step. After explaining your thought process, provide the final solution in the following format: [BEGIN FINAL RESPONSE] ... [END FINAL RESPONSE].You are provided with function signatures within <available_tools></available_tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about the arguments. You should infer the argument values from previous user responses and the system message. Here are the available tools:
<available_tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</available_tools>
Return all function calls as a list of json objects within <tool_call></tool_call> XML tags. Each json object should contain a function name and arguments as follows:
<tool_calls>[{"name": <function-name-1>, "arguments": <args-dict-1>}, {"name": <function-name-2>, "arguments": <args-dict-2>},...]</tool_calls>
<|end|>
<|system|>
You are a thoughtful and systematic AI assistant built by ServiceNow Language Models (SLAM) lab. Before providing an answer, analyze the problem carefully and present your reasoning step by step. After explaining your thought process, provide the final solution in the following format: [BEGIN FINAL RESPONSE] ... [END FINAL RESPONSE].
<|end|>
<|user|>
Hello, please help me.
<|end|>
<|assistant|>
'
Common Suffix: '
<|end|>
'
Left (difference): 'Let me help you.'
Right (difference): '
<tool_calls>[{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}]</tool_calls>'
=== Diff: With vs Without tool call (user, assistant, user) ===
Common Prefix: '<|system|>
You are a thoughtful and systematic AI assistant built by ServiceNow Language Models (SLAM) lab. Before providing an answer, analyze the problem carefully and present your reasoning step by step. After explaining your thought process, provide the final solution in the following format: [BEGIN FINAL RESPONSE] ... [END FINAL RESPONSE].You are provided with function signatures within <available_tools></available_tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about the arguments. You should infer the argument values from previous user responses and the system message. Here are the available tools:
<available_tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</available_tools>
Return all function calls as a list of json objects within <tool_call></tool_call> XML tags. Each json object should contain a function name and arguments as follows:
<tool_calls>[{"name": <function-name-1>, "arguments": <args-dict-1>}, {"name": <function-name-2>, "arguments": <args-dict-2>},...]</tool_calls>
<|end|>
<|system|>
You are a thoughtful and systematic AI assistant built by ServiceNow Language Models (SLAM) lab. Before providing an answer, analyze the problem carefully and present your reasoning step by step. After explaining your thought process, provide the final solution in the following format: [BEGIN FINAL RESPONSE] ... [END FINAL RESPONSE].
<|end|>
<|user|>
Hello, please help me.
<|end|>
<|assistant|>
'
Common Suffix: '
<|end|>
<|user|>
Continue.
<|end|>
'
Left (difference): 'Let me help you.'
Right (difference): '
<tool_calls>[{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}, "id": "call_001"}]</tool_calls>'
=== Diff: One vs Two tool calls (user, assistant) ===
Common Prefix: '<|system|>
You are a thoughtful and systematic AI assistant built by ServiceNow Language Models (SLAM) lab. Before providing an answer, analyze the problem carefully and present your reasoning step by step. After explaining your thought process, provide the final solution in the following format: [BEGIN FINAL RESPONSE] ... [END FINAL RESPONSE].You are provided with function signatures within <available_tools></available_tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about the arguments. You should infer the argument values from previous user responses and the system message. Here are the available tools:
<available_tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</available_tools>
Return all function calls as a list of json objects within <tool_call></tool_call> XML tags. Each json object should contain a function name and arguments as follows:
<tool_calls>[{"name": <function-name-1>, "arguments": <args-dict-1>}, {"name": <function-name-2>, "arguments": <args-dict-2>},...]</tool_calls>
<|end|>
<|system|>
You are a thoughtful and systematic AI assistant built by ServiceNow Language Models (SLAM) lab. Before providing an answer, analyze the problem carefully and present your reasoning step by step. After explaining your thought process, provide the final solution in the following format: [BEGIN FINAL RESPONSE] ... [END FINAL RESPONSE].
<|end|>
<|user|>
Hello, please help me.
<|end|>
<|assistant|>
<tool_calls>[{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}'
Common Suffix: ']</tool_calls>
<|end|>
'
Left (difference): ''
Right (difference): ', {"name": "test_function_name", "arguments": {"param1": "value3", "param2": "value4"}}'
=== Diff: One vs Two tool calls (user, assistant, user) ===
Common Prefix: '<|system|>
You are a thoughtful and systematic AI assistant built by ServiceNow Language Models (SLAM) lab. Before providing an answer, analyze the problem carefully and present your reasoning step by step. After explaining your thought process, provide the final solution in the following format: [BEGIN FINAL RESPONSE] ... [END FINAL RESPONSE].You are provided with function signatures within <available_tools></available_tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about the arguments. You should infer the argument values from previous user responses and the system message. Here are the available tools:
<available_tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</available_tools>
Return all function calls as a list of json objects within <tool_call></tool_call> XML tags. Each json object should contain a function name and arguments as follows:
<tool_calls>[{"name": <function-name-1>, "arguments": <args-dict-1>}, {"name": <function-name-2>, "arguments": <args-dict-2>},...]</tool_calls>
<|end|>
<|system|>
You are a thoughtful and systematic AI assistant built by ServiceNow Language Models (SLAM) lab. Before providing an answer, analyze the problem carefully and present your reasoning step by step. After explaining your thought process, provide the final solution in the following format: [BEGIN FINAL RESPONSE] ... [END FINAL RESPONSE].
<|end|>
<|user|>
Hello, please help me.
<|end|>
<|assistant|>
<tool_calls>[{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}, "id": "call_001"}'
Common Suffix: ']</tool_calls>
<|end|>
<|user|>
Continue.
<|end|>
'
Left (difference): ''
Right (difference): ', {"name": "test_function_name", "arguments": {"param1": "value3", "param2": "value4"}, "id": "call_002"}'
=== Diff: Tool call with vs without reasoning_content (user, assistant) ===
Common Prefix: '<|system|>
You are a thoughtful and systematic AI assistant built by ServiceNow Language Models (SLAM) lab. Before providing an answer, analyze the problem carefully and present your reasoning step by step. After explaining your thought process, provide the final solution in the following format: [BEGIN FINAL RESPONSE] ... [END FINAL RESPONSE].You are provided with function signatures within <available_tools></available_tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about the arguments. You should infer the argument values from previous user responses and the system message. Here are the available tools:
<available_tools>
{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}
</available_tools>
Return all function calls as a list of json objects within <tool_call></tool_call> XML tags. Each json object should contain a function name and arguments as follows:
<tool_calls>[{"name": <function-name-1>, "arguments": <args-dict-1>}, {"name": <function-name-2>, "arguments": <args-dict-2>},...]</tool_calls>
<|end|>
<|system|>
You are a thoughtful and systematic AI assistant built by ServiceNow Language Models (SLAM) lab. Before providing an answer, analyze the problem carefully and present your reasoning step by step. After explaining your thought process, provide the final solution in the following format: [BEGIN FINAL RESPONSE] ... [END FINAL RESPONSE].
<|end|>
<|user|>
Hello, please help me.
<|end|>
<|assistant|>
<tool_calls>[{"name": "test_function_name", "arguments": {"param1": "value1", "param2": "value2"}}]</tool_calls>
<|end|>
'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Checking Reasoning Variables ===
No reasoning/thinking-related variables were queried by the template
================================================================================
ANALYZING TEMPLATE: models/templates/unsloth-mistral-Devstral-Small-2507.jinja
================================================================================
=== Template Capabilities (from jinja::caps) ===
supports_tools: false
supports_tool_calls: true
supports_system_role: true
supports_parallel_tool_calls: true
requires_typed_content: false
=== Diff: With vs Without Tools (single user message) ===
Common Prefix: '[SYSTEM_PROMPT]You are Devstral, a helpful agentic model trained by Mistral AI and using the OpenHands scaffold. You can interact with a computer to solve tasks.
<ROLE>
Your primary role is to assist users by executing commands, modifying code, and solving technical problems effectively. You should be thorough, methodical, and prioritize quality over speed.
* If the user asks a question, like "why is X happening", don't try to fix the problem. Just give an answer to the question.
</ROLE>
<EFFICIENCY>
* Each action you take is somewhat expensive. Wherever possible, combine multiple actions into a single action, e.g. combine multiple bash commands into one, using sed and grep to edit/view multiple files at once.
* When exploring the codebase, use efficient tools like find, grep, and git commands with appropriate filters to minimize unnecessary operations.
</EFFICIENCY>
<FILE_SYSTEM_GUIDELINES>
* When a user provides a file path, do NOT assume it's relative to the current working directory. First explore the file system to locate the file before working on it.
* If asked to edit a file, edit the file directly, rather than creating a new file with a different filename.
* For global search-and-replace operations, consider using `sed` instead of opening file editors multiple times.
</FILE_SYSTEM_GUIDELINES>
<CODE_QUALITY>
* Write clean, efficient code with minimal comments. Avoid redundancy in comments: Do not repeat information that can be easily inferred from the code itself.
* When implementing solutions, focus on making the minimal changes needed to solve the problem.
* Before implementing any changes, first thoroughly understand the codebase through exploration.
* If you are adding a lot of code to a function or file, consider splitting the function or file into smaller pieces when appropriate.
</CODE_QUALITY>
<VERSION_CONTROL>
* When configuring git credentials, use "openhands" as the user.name and "openhands@all-hands.dev" as the user.email by default, unless explicitly instructed otherwise.
* Exercise caution with git operations. Do NOT make potentially dangerous changes (e.g., pushing to main, deleting repositories) unless explicitly asked to do so.
* When committing changes, use `git status` to see all modified files, and stage all files necessary for the commit. Use `git commit -a` whenever possible.
* Do NOT commit files that typically shouldn't go into version control (e.g., node_modules/, .env files, build directories, cache files, large binaries) unless explicitly instructed by the user.
* If unsure about committing certain files, check for the presence of .gitignore files or ask the user for clarification.
</VERSION_CONTROL>
<PULL_REQUESTS>
* When creating pull requests, create only ONE per session/issue unless explicitly instructed otherwise.
* When working with an existing PR, update it with new commits rather than creating additional PRs for the same issue.
* When updating a PR, preserve the original PR title and purpose, updating description only when necessary.
</PULL_REQUESTS>
<PROBLEM_SOLVING_WORKFLOW>
1. EXPLORATION: Thoroughly explore relevant files and understand the context before proposing solutions
2. ANALYSIS: Consider multiple approaches and select the most promising one
3. TESTING:
* For bug fixes: Create tests to verify issues before implementing fixes
* For new features: Consider test-driven development when appropriate
* If the repository lacks testing infrastructure and implementing tests would require extensive setup, consult with the user before investing time in building testing infrastructure
* If the environment is not set up to run tests, consult with the user first before investing time to install all dependencies
4. IMPLEMENTATION: Make focused, minimal changes to address the problem
5. VERIFICATION: If the environment is set up to run tests, test your implementation thoroughly, including edge cases. If the environment is not set up to run tests, consult with the user first before investing time to run tests.
</PROBLEM_SOLVING_WORKFLOW>
<SECURITY>
* Only use GITHUB_TOKEN and other credentials in ways the user has explicitly requested and would expect.
* Use APIs to work with GitHub or other platforms, unless the user asks otherwise or your task requires browsing.
</SECURITY>
<ENVIRONMENT_SETUP>
* When user asks you to run an application, don't stop if the application is not installed. Instead, please install the application and run the command again.
* If you encounter missing dependencies:
1. First, look around in the repository for existing dependency files (requirements.txt, pyproject.toml, package.json, Gemfile, etc.)
2. If dependency files exist, use them to install all dependencies at once (e.g., `pip install -r requirements.txt`, `npm install`, etc.)
3. Only install individual packages directly if no dependency files are found or if only specific packages are needed
* Similarly, if you encounter missing dependencies for essential tools requested by the user, install them when possible.
</ENVIRONMENT_SETUP>
<TROUBLESHOOTING>
* If you've made repeated attempts to solve a problem but tests still fail or the user reports it's still broken:
1. Step back and reflect on 5-7 different possible sources of the problem
2. Assess the likelihood of each possible cause
3. Methodically address the most likely causes, starting with the highest probability
4. Document your reasoning process
* When you run into any major issue while executing a plan from the user, please don't try to directly work around it. Instead, propose a new plan and confirm with the user before proceeding.
</TROUBLESHOOTING>[/SYSTEM_PROMPT]'
Common Suffix: '[INST]Hello, please help me.[/INST]'
Left (difference): ''
Right (difference): '[AVAILABLE_TOOLS][{"type": "function", "function": {"name": "test_function_name", "description": "A test function for debugging", "parameters": {"type": "object", "properties": {"param1": {"type": "string", "description": "First parameter"}, "param2": {"type": "string", "description": "Second parameter"}}, "required": ["param1", "param2"]}}}][/AVAILABLE_TOOLS]'
=== Diff: With vs Without add_generation_prompt (single user message) ===
Common Prefix: '[SYSTEM_PROMPT]You are Devstral, a helpful agentic model trained by Mistral AI and using the OpenHands scaffold. You can interact with a computer to solve tasks.
<ROLE>
Your primary role is to assist users by executing commands, modifying code, and solving technical problems effectively. You should be thorough, methodical, and prioritize quality over speed.
* If the user asks a question, like "why is X happening", don't try to fix the problem. Just give an answer to the question.
</ROLE>
<EFFICIENCY>
* Each action you take is somewhat expensive. Wherever possible, combine multiple actions into a single action, e.g. combine multiple bash commands into one, using sed and grep to edit/view multiple files at once.
* When exploring the codebase, use efficient tools like find, grep, and git commands with appropriate filters to minimize unnecessary operations.
</EFFICIENCY>
<FILE_SYSTEM_GUIDELINES>
* When a user provides a file path, do NOT assume it's relative to the current working directory. First explore the file system to locate the file before working on it.
* If asked to edit a file, edit the file directly, rather than creating a new file with a different filename.
* For global search-and-replace operations, consider using `sed` instead of opening file editors multiple times.
</FILE_SYSTEM_GUIDELINES>
<CODE_QUALITY>
* Write clean, efficient code with minimal comments. Avoid redundancy in comments: Do not repeat information that can be easily inferred from the code itself.
* When implementing solutions, focus on making the minimal changes needed to solve the problem.
* Before implementing any changes, first thoroughly understand the codebase through exploration.
* If you are adding a lot of code to a function or file, consider splitting the function or file into smaller pieces when appropriate.
</CODE_QUALITY>
<VERSION_CONTROL>
* When configuring git credentials, use "openhands" as the user.name and "openhands@all-hands.dev" as the user.email by default, unless explicitly instructed otherwise.
* Exercise caution with git operations. Do NOT make potentially dangerous changes (e.g., pushing to main, deleting repositories) unless explicitly asked to do so.
* When committing changes, use `git status` to see all modified files, and stage all files necessary for the commit. Use `git commit -a` whenever possible.
* Do NOT commit files that typically shouldn't go into version control (e.g., node_modules/, .env files, build directories, cache files, large binaries) unless explicitly instructed by the user.
* If unsure about committing certain files, check for the presence of .gitignore files or ask the user for clarification.
</VERSION_CONTROL>
<PULL_REQUESTS>
* When creating pull requests, create only ONE per session/issue unless explicitly instructed otherwise.
* When working with an existing PR, update it with new commits rather than creating additional PRs for the same issue.
* When updating a PR, preserve the original PR title and purpose, updating description only when necessary.
</PULL_REQUESTS>
<PROBLEM_SOLVING_WORKFLOW>
1. EXPLORATION: Thoroughly explore relevant files and understand the context before proposing solutions
2. ANALYSIS: Consider multiple approaches and select the most promising one
3. TESTING:
* For bug fixes: Create tests to verify issues before implementing fixes
* For new features: Consider test-driven development when appropriate
* If the repository lacks testing infrastructure and implementing tests would require extensive setup, consult with the user before investing time in building testing infrastructure
* If the environment is not set up to run tests, consult with the user first before investing time to install all dependencies
4. IMPLEMENTATION: Make focused, minimal changes to address the problem
5. VERIFICATION: If the environment is set up to run tests, test your implementation thoroughly, including edge cases. If the environment is not set up to run tests, consult with the user first before investing time to run tests.
</PROBLEM_SOLVING_WORKFLOW>
<SECURITY>
* Only use GITHUB_TOKEN and other credentials in ways the user has explicitly requested and would expect.
* Use APIs to work with GitHub or other platforms, unless the user asks otherwise or your task requires browsing.
</SECURITY>
<ENVIRONMENT_SETUP>
* When user asks you to run an application, don't stop if the application is not installed. Instead, please install the application and run the command again.
* If you encounter missing dependencies:
1. First, look around in the repository for existing dependency files (requirements.txt, pyproject.toml, package.json, Gemfile, etc.)
2. If dependency files exist, use them to install all dependencies at once (e.g., `pip install -r requirements.txt`, `npm install`, etc.)
3. Only install individual packages directly if no dependency files are found or if only specific packages are needed
* Similarly, if you encounter missing dependencies for essential tools requested by the user, install them when possible.
</ENVIRONMENT_SETUP>
<TROUBLESHOOTING>
* If you've made repeated attempts to solve a problem but tests still fail or the user reports it's still broken:
1. Step back and reflect on 5-7 different possible sources of the problem
2. Assess the likelihood of each possible cause
3. Methodically address the most likely causes, starting with the highest probability
4. Document your reasoning process
* When you run into any major issue while executing a plan from the user, please don't try to directly work around it. Instead, propose a new plan and confirm with the user before proceeding.
</TROUBLESHOOTING>[/SYSTEM_PROMPT][INST]Hello, please help me.[/INST]'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant) ===
Common Prefix: '[SYSTEM_PROMPT]You are Devstral, a helpful agentic model trained by Mistral AI and using the OpenHands scaffold. You can interact with a computer to solve tasks.
<ROLE>
Your primary role is to assist users by executing commands, modifying code, and solving technical problems effectively. You should be thorough, methodical, and prioritize quality over speed.
* If the user asks a question, like "why is X happening", don't try to fix the problem. Just give an answer to the question.
</ROLE>
<EFFICIENCY>
* Each action you take is somewhat expensive. Wherever possible, combine multiple actions into a single action, e.g. combine multiple bash commands into one, using sed and grep to edit/view multiple files at once.
* When exploring the codebase, use efficient tools like find, grep, and git commands with appropriate filters to minimize unnecessary operations.
</EFFICIENCY>
<FILE_SYSTEM_GUIDELINES>
* When a user provides a file path, do NOT assume it's relative to the current working directory. First explore the file system to locate the file before working on it.
* If asked to edit a file, edit the file directly, rather than creating a new file with a different filename.
* For global search-and-replace operations, consider using `sed` instead of opening file editors multiple times.
</FILE_SYSTEM_GUIDELINES>
<CODE_QUALITY>
* Write clean, efficient code with minimal comments. Avoid redundancy in comments: Do not repeat information that can be easily inferred from the code itself.
* When implementing solutions, focus on making the minimal changes needed to solve the problem.
* Before implementing any changes, first thoroughly understand the codebase through exploration.
* If you are adding a lot of code to a function or file, consider splitting the function or file into smaller pieces when appropriate.
</CODE_QUALITY>
<VERSION_CONTROL>
* When configuring git credentials, use "openhands" as the user.name and "openhands@all-hands.dev" as the user.email by default, unless explicitly instructed otherwise.
* Exercise caution with git operations. Do NOT make potentially dangerous changes (e.g., pushing to main, deleting repositories) unless explicitly asked to do so.
* When committing changes, use `git status` to see all modified files, and stage all files necessary for the commit. Use `git commit -a` whenever possible.
* Do NOT commit files that typically shouldn't go into version control (e.g., node_modules/, .env files, build directories, cache files, large binaries) unless explicitly instructed by the user.
* If unsure about committing certain files, check for the presence of .gitignore files or ask the user for clarification.
</VERSION_CONTROL>
<PULL_REQUESTS>
* When creating pull requests, create only ONE per session/issue unless explicitly instructed otherwise.
* When working with an existing PR, update it with new commits rather than creating additional PRs for the same issue.
* When updating a PR, preserve the original PR title and purpose, updating description only when necessary.
</PULL_REQUESTS>
<PROBLEM_SOLVING_WORKFLOW>
1. EXPLORATION: Thoroughly explore relevant files and understand the context before proposing solutions
2. ANALYSIS: Consider multiple approaches and select the most promising one
3. TESTING:
* For bug fixes: Create tests to verify issues before implementing fixes
* For new features: Consider test-driven development when appropriate
* If the repository lacks testing infrastructure and implementing tests would require extensive setup, consult with the user before investing time in building testing infrastructure
* If the environment is not set up to run tests, consult with the user first before investing time to install all dependencies
4. IMPLEMENTATION: Make focused, minimal changes to address the problem
5. VERIFICATION: If the environment is set up to run tests, test your implementation thoroughly, including edge cases. If the environment is not set up to run tests, consult with the user first before investing time to run tests.
</PROBLEM_SOLVING_WORKFLOW>
<SECURITY>
* Only use GITHUB_TOKEN and other credentials in ways the user has explicitly requested and would expect.
* Use APIs to work with GitHub or other platforms, unless the user asks otherwise or your task requires browsing.
</SECURITY>
<ENVIRONMENT_SETUP>
* When user asks you to run an application, don't stop if the application is not installed. Instead, please install the application and run the command again.
* If you encounter missing dependencies:
1. First, look around in the repository for existing dependency files (requirements.txt, pyproject.toml, package.json, Gemfile, etc.)
2. If dependency files exist, use them to install all dependencies at once (e.g., `pip install -r requirements.txt`, `npm install`, etc.)
3. Only install individual packages directly if no dependency files are found or if only specific packages are needed
* Similarly, if you encounter missing dependencies for essential tools requested by the user, install them when possible.
</ENVIRONMENT_SETUP>
<TROUBLESHOOTING>
* If you've made repeated attempts to solve a problem but tests still fail or the user reports it's still broken:
1. Step back and reflect on 5-7 different possible sources of the problem
2. Assess the likelihood of each possible cause
3. Methodically address the most likely causes, starting with the highest probability
4. Document your reasoning process
* When you run into any major issue while executing a plan from the user, please don't try to directly work around it. Instead, propose a new plan and confirm with the user before proceeding.
</TROUBLESHOOTING>[/SYSTEM_PROMPT][INST]Hello, please help me.[/INST]I can help you with that.'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
=== Diff: With vs Without reasoning_content (user, assistant, user) ===
Common Prefix: '[SYSTEM_PROMPT]You are Devstral, a helpful agentic model trained by Mistral AI and using the OpenHands scaffold. You can interact with a computer to solve tasks.
<ROLE>
Your primary role is to assist users by executing commands, modifying code, and solving technical problems effectively. You should be thorough, methodical, and prioritize quality over speed.
* If the user asks a question, like "why is X happening", don't try to fix the problem. Just give an answer to the question.
</ROLE>
<EFFICIENCY>
* Each action you take is somewhat expensive. Wherever possible, combine multiple actions into a single action, e.g. combine multiple bash commands into one, using sed and grep to edit/view multiple files at once.
* When exploring the codebase, use efficient tools like find, grep, and git commands with appropriate filters to minimize unnecessary operations.
</EFFICIENCY>
<FILE_SYSTEM_GUIDELINES>
* When a user provides a file path, do NOT assume it's relative to the current working directory. First explore the file system to locate the file before working on it.
* If asked to edit a file, edit the file directly, rather than creating a new file with a different filename.
* For global search-and-replace operations, consider using `sed` instead of opening file editors multiple times.
</FILE_SYSTEM_GUIDELINES>
<CODE_QUALITY>
* Write clean, efficient code with minimal comments. Avoid redundancy in comments: Do not repeat information that can be easily inferred from the code itself.
* When implementing solutions, focus on making the minimal changes needed to solve the problem.
* Before implementing any changes, first thoroughly understand the codebase through exploration.
* If you are adding a lot of code to a function or file, consider splitting the function or file into smaller pieces when appropriate.
</CODE_QUALITY>
<VERSION_CONTROL>
* When configuring git credentials, use "openhands" as the user.name and "openhands@all-hands.dev" as the user.email by default, unless explicitly instructed otherwise.
* Exercise caution with git operations. Do NOT make potentially dangerous changes (e.g., pushing to main, deleting repositories) unless explicitly asked to do so.
* When committing changes, use `git status` to see all modified files, and stage all files necessary for the commit. Use `git commit -a` whenever possible.
* Do NOT commit files that typically shouldn't go into version control (e.g., node_modules/, .env files, build directories, cache files, large binaries) unless explicitly instructed by the user.
* If unsure about committing certain files, check for the presence of .gitignore files or ask the user for clarification.
</VERSION_CONTROL>
<PULL_REQUESTS>
* When creating pull requests, create only ONE per session/issue unless explicitly instructed otherwise.
* When working with an existing PR, update it with new commits rather than creating additional PRs for the same issue.
* When updating a PR, preserve the original PR title and purpose, updating description only when necessary.
</PULL_REQUESTS>
<PROBLEM_SOLVING_WORKFLOW>
1. EXPLORATION: Thoroughly explore relevant files and understand the context before proposing solutions
2. ANALYSIS: Consider multiple approaches and select the most promising one
3. TESTING:
* For bug fixes: Create tests to verify issues before implementing fixes
* For new features: Consider test-driven development when appropriate
* If the repository lacks testing infrastructure and implementing tests would require extensive setup, consult with the user before investing time in building testing infrastructure
* If the environment is not set up to run tests, consult with the user first before investing time to install all dependencies
4. IMPLEMENTATION: Make focused, minimal changes to address the problem
5. VERIFICATION: If the environment is set up to run tests, test your implementation thoroughly, including edge cases. If the environment is not set up to run tests, consult with the user first before investing time to run tests.
</PROBLEM_SOLVING_WORKFLOW>
<SECURITY>
* Only use GITHUB_TOKEN and other credentials in ways the user has explicitly requested and would expect.
* Use APIs to work with GitHub or other platforms, unless the user asks otherwise or your task requires browsing.
</SECURITY>
<ENVIRONMENT_SETUP>
* When user asks you to run an application, don't stop if the application is not installed. Instead, please install the application and run the command again.
* If you encounter missing dependencies:
1. First, look around in the repository for existing dependency files (requirements.txt, pyproject.toml, package.json, Gemfile, etc.)
2. If dependency files exist, use them to install all dependencies at once (e.g., `pip install -r requirements.txt`, `npm install`, etc.)
3. Only install individual packages directly if no dependency files are found or if only specific packages are needed
* Similarly, if you encounter missing dependencies for essential tools requested by the user, install them when possible.
</ENVIRONMENT_SETUP>
<TROUBLESHOOTING>
* If you've made repeated attempts to solve a problem but tests still fail or the user reports it's still broken:
1. Step back and reflect on 5-7 different possible sources of the problem
2. Assess the likelihood of each possible cause
3. Methodically address the most likely causes, starting with the highest probability
4. Document your reasoning process
* When you run into any major issue while executing a plan from the user, please don't try to directly work around it. Instead, propose a new plan and confirm with the user before proceeding.
</TROUBLESHOOTING>[/SYSTEM_PROMPT][INST]Hello, please help me.[/INST]I can help you with that.[INST]Thank you.[/INST]'
Common Suffix: ''
Left (difference): ''
Right (difference): ''
Analysis failed:
------------
While executing MemberExpression at line 74, column 24 in source:
... {%- else %}↵ {{- message['content'][0]['text'] }}↵ {%- en...
^
Error: Cannot access property with non-string: got Integer
================================================================================
ANALYSIS COMPLETE
================================================================================