File size: 28,465 Bytes

---
library_name: transformers
license: apache-2.0
datasets:
- Vikhrmodels/tool-plannings-v0.1
language:
- en
base_model:
- Qwen/Qwen2.5-7B-Instruct
pipeline_tag: text-generation
tags:
- function-calling
- tools
- tool-calling
- tool-planning
---
# Vikhrmodels/Qwen2.5-7B-Instruct-Tool-Planning-v0.1

<!-- Provide a quick summary of what the model is/does. -->

This model is a experimental supervised fine-tuned version of [Qwen/Qwen2.5-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-7B-Instruct) for the **Tool Planning** 
task on synthetic data of the English [Vikhrmodels/tool-plannings-v0.1](https://huggingface.co/datasets/Vikhrmodels/tool-plannings-v0.1) dataset.

**Tool Planning** means modified version of **Function Calling** task with additional model's capabilities of reasoning about calls.

In this model, the features include:
* **Simple Function** — the model has <u>*one*</u> function in its arsenal, and it is able to call it if necessary at the user's common request. 
* **Multiple Function** — the model has <u>*several*</u> functions in its arsenal, and it is able to call <u>*one of them*</u> if necessary at the user's request.
* **Parallel Multiple Function** — the model has <u>*several*</u> functions in its arsenal, and it is able to call <u>*some of them*</u> if necessary at the user's request.
* **Tool Planning** — firstly the model is <u>*thinking*</u> about user's intent of function calling and secondly does calling.
* **Tool Relevance Detection** — the model is able to determine the relevance of a function calling.
* **Tool Error Handling** — the model is able to react non-hallucinative to broken/erroneous tool executions.

All examples of these features are described below.

## Model card tree

* [Usage (HuggingFace Transformers)](#usage_hf)
* [Usage (VLLM)](#usage_vllm)
* [Tool Planning Examples](#examples)
* [Limitations](#lim)
* [Evaluation](#eval)

## Usage (HuggingFace Transformers) <a name="usage_hf"></a>

Below we share some code snippets on how to get quickly started with running the model. First, install the Transformers library with:
```bash
pip install transformers==4.48.3
```

### Prepare your functions

You should write the functions (tools) used by the model in *Python code* and make sure to add *Python docstrings* as in the example below:
```python
def get_weather(city: str):
    """
    A function that returns the weather in a given city.
    
    Args:
        city: The city to get the weather for.
    """
    import random
    
    return "sunny" if random.random() > 0.5 else "rainy"

# Either immediately in JSON format:
get_sunrise_sunset_times = {
  "type": "function",
  "function": {
    "name": "get_sunrise_sunset_times",
    "description": "A function that returns the time of sunrise and sunset at the present moment, for a given city, in the form of a list: [sunrise_time, sunset_time].",
    "parameters": {
      "type": "object",
      "properties": {
        "city": {
          "type": "string",
          "description": "The city to get the sunrise and sunset times for."
        }
      },
      "required": ["city"]
    }
  }
}

tools = [get_weather, get_sunrise_sunset_times]
```

### Just use chat template

Next, you need to download the model and tokenizer:
```python
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained(
    "Vikhrmodels/Qwen2.5-7B-Instruct-Tool-Planning-v0.1",
    device_map="auto",
    torch_dtype=torch.bfloat16,  # recommended dtype 
)
tokenizer = AutoTokenizer.from_pretrained(
    "Vikhrmodels/Qwen2.5-7B-Instruct-Tool-Planning-v0.1",
)
```

To get the result of generation, just use `apply_chat_template`. In order to take into account our written functions (tools), 
we need to pass them as a list through the `tools` attribute and also use `add_prompt_generation=True`.
```python
history_messages = [
    {"role": "user", "content": "Hi, can you tell me the time of sunrise in Los Angeles?"},
]

inputs = tokenizer.apply_chat_template(
    history_messages,
    tokenize=False,
    add_generation_prompt=True,  # adding prompt for generation
    tools=tools,  # our functions (tools)
)

input_tokens =  tokenizer(
  inputs,
  add_special_tokens=False,
  return_tensors='pt'
).to(model.device)

generated_ids = model.generate(
    **input_tokens,
    max_new_tokens=256,
    do_sample=False,
)[0]

generated_response = tokenizer.decode(
  generated_ids[input_tokens.input_ids.shape[-1]:],
  skip_special_tokens=False,  # `skip_special_tokens=False` for debug
)
print(generated_response)
```

Then our `generated_response` will look like this:
```
<|start_thinking|>The user wants to know the time of sunrise in Los Angeles. I will use the get_sunrise_sunset_times API to retrieve this information.<|end_thinking|><tool_call>[
  {"tool_call_id": "0", "tool_name": "get_sunrise_sunset_times", "parameters": {"city": "Los Angeles"}}
]</tool_call><|im_end|>
```

## Usage (VLLM) <a name="usage_vllm"></a>

For corrected work online serving in VLLM you need additionally load [qwen2_tool_parser.py]() and [chat_template.jinja]() from this repository.

```
vllm serve Vikhrmodels/Qwen2.5-7B-Instruct-Tool-Planning-v0.1 \
--download-dir "/path/to/cache" \
--chat-template "/path/to/chat_template.jinja" \
--tool-parser-plugin "/path/to/qwen2_tool_parser.py" \
--tool-call-parser "qwen2" \
--enable-auto-tool-choice
```

After that you can start doing requests:

```python
from openai import OpenAI
import json

client = OpenAI(base_url="http://localhost:8000/v1", api_key="dummy")
tools = [
  {
    "type": "function",
    "function": {
      "name": "get_weather",
      "description": "Get the current weather in a given location",
      "parameters": {
        "type": "object",
        "properties": {
        "location": {"type": "string", "description": "City and state."},
      },
      "required": ["location"]
      }
    }
  }
]

response = client.chat.completions.create(
  model=client.models.list().data[0].id,
  messages=[
    {"role": "user", "content": "What's the weather in Krasnodar and Moscow?"}
  ],
  tools=tools,
)

print(response.choices[0].message)
```

```
ChatCompletionMessage(
  content='<|start_thinking|>I need to get the weather for Krasnodar and Moscow.<|end_thinking|>',
  refusal=None,
  role='assistant',
  audio=None,
  function_call=None,
  tool_calls=[
    ChatCompletionMessageToolCall(
      id='chatcmpl-tool-73646c73148e4af9ac53656d6aa3e3c6',
      function=Function(arguments='{"location": "Krasnodar"}', name='get_weather'),
      type='function'),
    ChatCompletionMessageToolCall(
      id='chatcmpl-tool-95d93590d1a24df6a4f44a87a83f7761',
      function=Function(arguments='{"location": "Moscow"}', name='get_weather'),
      type='function')
  ],
  reasoning_content=None)
```

## Tool Planning Examples <a name="examples"></a>

The model is using ***grounded system prompt*** for tool planning. <u>We do not recommend changing it too much, as this may cause hallucinations!</u>

But you can try to add first message as `system` role with additional system rules in your chat history and it adds at the end of this ***grounded system prompt***.

```
<|im_start|>system
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 <tool_call> 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 </tool_call>.
2. Observation: you will then receive results of those tool calls in JSON format in the very next turn, wrapped around by <tool_response> and </tool_response>. 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": "get_weather", "description": "A function that returns the weather in a given city.", "parameters": {"type": "object", "properties": {"city": {"type": "string", "description": "The city to get the weather for."}}, "required": ["city"]}, "responses": null},
    {"name": "get_sunrise_sunset_times", "description": "A function that returns the time of sunrise and sunset at the present moment, for a given city, in the form of a list: [sunrise_time, sunset_time].", "parameters": {"type": "object", "properties": {"city": {"type": "string", "description": "The city to get the sunrise and sunset times for."}}, "required": ["city"]}, "responses": null}
]
\`\`\`

<|im_end|>
```
*For corrected display used [\ \`] instead of [\`]*

**About the structure of prompt:**
- This model always will answer with new tokens: `<|start_response|>`...*text from model*...`<|end_response|>`. This content is the main one for user and it contains in `assistant` in `content` field.
- This model always starts <u>*thinking*</u> before tool calls with new tokens: `<|start_thinking|>`...*thinking*...`<|end_thinking|>`. It contains in `assistant` in `tool_plan` field.
- After <u>*thinking*</u> model starts generate tool calls (function calling) with Qwen2.5 tokens (it can be a multiple/parallel calling too):
```
<tool_call>[
  {"tool_call_id": "...", "tool_name": "...", "parameters": {...}},
  {"tool_call_id": "...", "tool_name": "...", "parameters": {...}},
  ...
]</tool_call><|im_end|> 
```
`tool_call_id` is local tool id.<br>
`tool_name` is name of tool(function) calling.<br>
It contains in `assistant` in `tool_calls` field.<br>

- Responses from tools are located between `<tool_response>`...*all last locals tools*...`</tool_response>`. Every local tool contains separately in specific role `tool`:
```python
{
    "role": "tool", 
    "tool_call_id": "0",  # MUST BE matches with the corresponding call above.
    "content": { "tool_name_1_returns": ... }  # MUST BE dict with key "tool_name" + "_returns"
},
{
    "role": "tool", 
    "tool_call_id": "1",  # MUST BE matches with the corresponding call above.
    "content": { "tool_name_1_returns": ... }
},
{
    "role": "tool", 
    "tool_call_id": "2",  # MUST BE matches with the corresponding call above.
    "content": { "tool_name_2_returns": ... },
    "is_error_tool": True  # You can add it if your tool is corrupted. But then you must provide error description in content.
}
```
Local tool ids mean that ids must match only in one pair *tool call* and *tool response*, next *tool call* must reset the counter and start from 0 again.

### Simple Function

*history*
```python
messages = [
  {"role": "user", "content": "Hey dude, what can you do?"},
  {"role": "assistant", "content": "I can retrieve a list of unpaid invoices and process payments for specific invoices."},
  {"role": "user", "content": "Okey, then retrieve a list for me"},
  {
      "role": "assistant",
      "tool_plan": "I will retrieve a list of unpaid invoices.",
      "tool_calls": [ 
          {
              "id": "0",
              "type": "function",
              "function": {
                  "name": "find_unpaid_invoices",
                  "arguments": {}
              }
          }
      ]
  },
  {
      "role": "tool", 
      "tool_call_id": "0",
      "content": { "find_unpaid_invoices_returns": ["Utility Debts", "Housing and Utilities Arrears"]}
  },
  {"role": "assistant", "content": "Here is the list of unpaid invoices: Utility Debts and Housing and Utilities Arrears."},
  {"role": "user", "content": "Ooh, I forget about this! Lets pay Utility Debts in the amount of $100 please"},
  {
      "role": "assistant",
      "tool_plan": "I will process the payment for the Utility Debts invoice.",
      "tool_calls": [
          {
              "id": "0",
              "type": "function",
              "function": {
                  "name": "pay_invoice",
                  "arguments": {"invoice_id": "Utility Debts", "amount": 100}
              }
          }
      ]
  },
  {
      "role": "tool", 
      "tool_call_id": "0",
      "content": { "pay_invoice_returns": "Success"}
  },
]
```

*prompt with generation*
```
<|im_start|>system
...grounded_system_prompt...

<|im_end|>
<|im_start|>user
Hey dude, what can you do?<|im_end|>
<|im_start|>assistant
<|start_response|>I can retrieve a list of unpaid invoices and process payments for specific invoices.<|end_response|><|im_end|>
<|im_start|>user
Okey, then retrieve a list for me<|im_end|>
<|im_start|>assistant
<|start_thinking|>I will retrieve a list of unpaid invoices.<|end_thinking|><tool_call>[
    {"tool_call_id": "0", "tool_name": "find_unpaid_invoices", "parameters": {}}
]</tool_call><|im_end|>
<|im_start|>system
<tool_response>[
    {
        "tool_call_id": "0",
        "results": {
            "0": {"find_unpaid_invoices_returns": ["Utility Debts", "Housing and Utilities Arrears"]}
        },
        "is_error_tool": False
    }
]</tool_response><|im_end|>
<|im_start|>assistant
<|start_response|>Here is the list of unpaid invoices: Utility Debts and Housing and Utilities Arrears.<|end_response|><|im_end|>
<|im_start|>user
Ooh, I forget about this! Lets pay Utility Debts in the amount of $100 please<|im_end|>
<|im_start|>assistant
<|start_thinking|>I will process the payment for the Utility Debts invoice.<|end_thinking|><tool_call>[
    {"tool_call_id": "0", "tool_name": "pay_invoice", "parameters": {"invoice_id": "Utility Debts", "amount": 100}}
]</tool_call><|im_end|>
<|im_start|>system
<tool_response>[
    {
        "tool_call_id": "0",
        "results": {
            "0": {"pay_invoice_returns": "Success"}
        },
        "is_error_tool": False
    }
]</tool_response><|im_end|>
<|im_start|>assistant
<|start_response|>The payment for the Utility Debts invoice has been processed successfully.<|end_response|><|im_end|>
```

### Multiple Function

*history*
```python
messages = [
  {"role": "user", "content": "Hey dude, what can you do?"},
  {"role": "assistant", "content": "I can provide weather information for a given city and also provide the sunrise and sunset times for a given city."},
  {"role": "user", "content": "Thats great! Okey, can you provide weather in Krasnodar, Moscow and Krasnoyarsk for me please."},
  {
      "role": "assistant",
      "tool_plan": "The user wants weather information for three cities: Krasnodar, Moscow, and Krasnoyarsk.",
      "tool_calls": [ 
          {
              "id": "0",
              "type": "function",
              "function": {
                  "name": "get_weather",
                  "arguments": {
                      "city": "Krasnodar"
                  }
              }
          },
          {
              "id": "1",
              "type": "function",
              "function": {
                  "name": "get_weather",
                  "arguments": {
                      "city": "Moscow"
                  }
              }
          },
          {
              "id": "2",
              "type": "function",
              "function": {
                  "name": "get_weather",
                  "arguments": {
                      "city": "Krasnoyarsk"
                  }
              }
          },
      ]
  },
  {
      "role": "tool", 
      "tool_call_id": "0",
      "content": { "get_weather_returns": "sunny" }
  },
  {
      "role": "tool", 
      "tool_call_id": "1",
      "content": { "get_weather_returns": "sunny" }
  },
  {
      "role": "tool", 
      "tool_call_id": "2",
      "content": { "get_weather_returns": "rainy" }
  },
] 
```

*prompt with generation*
```
<|im_start|>system
...grounded_system_prompt...

<|im_end|>
<|im_start|>user
Hey dude, what can you do?<|im_end|>
<|im_start|>assistant
<|start_response|>I can provide weather information for a given city and also provide the sunrise and sunset times for a given city.<|end_response|><|im_end|>
<|im_start|>user
Thats great! Okey, can you provide weather in Krasnodar, Moscow and Krasnoyarsk for me please.<|im_end|>
<|im_start|>assistant
<|start_thinking|>The user wants weather information for three cities: Krasnodar, Moscow, and Krasnoyarsk.<|end_thinking|><tool_call>[
    {"tool_call_id": "0", "tool_name": "get_weather", "parameters": {"city": "Krasnodar"}},
    {"tool_call_id": "1", "tool_name": "get_weather", "parameters": {"city": "Moscow"}},
    {"tool_call_id": "2", "tool_name": "get_weather", "parameters": {"city": "Krasnoyarsk"}}
]</tool_call><|im_end|>
<|im_start|>system
<tool_response>[
    {
        "tool_call_id": "0",
        "results": {
            "0": {"get_weather_returns": "sunny"}
        },
        "is_error_tool": False
    },
    {
        "tool_call_id": "1",
        "results": {
            "0": {"get_weather_returns": "sunny"}
        },
        "is_error_tool": False
    },
    {
        "tool_call_id": "2",
        "results": {
            "0": {"get_weather_returns": "rainy"}
        },
        "is_error_tool": False
    }
]</tool_response><|im_end|>
<|im_start|>assistant
<|start_response|>The weather in Krasnodar is sunny, the weather in Moscow is sunny, and the weather in Krasnoyarsk is rainy.<|end_response|><|im_end|>
```

### Parallel Multiple Function

*history*
```python
messages = [
  {"role": "user", "content": "Hey dude, what can you do?"},
  {"role": "assistant", "content": "I can provide weather information for a given city and also provide the sunrise and sunset times for a given city."},
  {"role": "user", "content": "Thats great! Okey, can you provide weather in Krasnodar, Moscow and only the sunrise time in Krasnoyarsk for me please."},
  {
      "role": "assistant",
      "tool_plan": "The user has requested weather information for three cities and only the sunrise time for one city. I will first retrieve the weather information for Krasnodar and Moscow, and then retrieve the sunrise time for Krasnoyarsk.",
      "tool_calls": [ 
          {
              "id": "0",
              "type": "function",
              "function": {
                  "name": "get_weather",
                  "arguments": {
                      "city": "Krasnodar"
                  }
              }
          },
          {
              "id": "1",
              "type": "function",
              "function": {
                  "name": "get_weather",
                  "arguments": {
                      "city": "Moscow"
                  }
              }
          },
          {
              "id": "2",
              "type": "function",
              "function": {
                  "name": "get_sunrise_sunset_times",
                  "arguments": {
                      "city": "Krasnoyarsk"
                  }
              }
          },
      ]
  },
  {
      "role": "tool", 
      "tool_call_id": "0",
      "content": { "get_weather_returns": "sunny" }
  },
  {
      "role": "tool", 
      "tool_call_id": "1",
      "content": { "get_weather_returns": "sunny" }
  },
  {
      "role": "tool", 
      "tool_call_id": "2",
      "content": { "get_sunrise_sunset_times_returns": ["6:00 AM", "6:00 PM"] }
  },
] 
```

*prompt with generation*
```
<|im_start|>system
...grounded_system_prompt...

<|im_end|>
<|im_start|>user
Hey dude, what can you do?<|im_end|>
<|im_start|>assistant
<|start_response|>I can provide weather information for a given city and also provide the sunrise and sunset times for a given city.<|end_response|><|im_end|>
<|im_start|>user
Thats great! Okey, can you provide weather in Krasnodar, Moscow and only the sunrise time in Krasnoyarsk for me please.<|im_end|>
<|im_start|>assistant
<|start_thinking|>The user has requested weather information for three cities and only the sunrise time for one city. I will first retrieve the weather information for Krasnodar and Moscow, and then retrieve the sunrise time for Krasnoyarsk.<|end_thinking|><tool_call>[
    {"tool_call_id": "0", "tool_name": "get_weather", "parameters": {"city": "Krasnodar"}},
    {"tool_call_id": "1", "tool_name": "get_weather", "parameters": {"city": "Moscow"}},
    {"tool_call_id": "2", "tool_name": "get_sunrise_sunset_times", "parameters": {"city": "Krasnoyarsk"}}
]</tool_call><|im_end|>
<|im_start|>system
<tool_response>[
    {
        "tool_call_id": "0",
        "results": {
            "0": {"get_weather_returns": "sunny"}
        },
        "is_error_tool": False
    },
    {
        "tool_call_id": "1",
        "results": {
            "0": {"get_weather_returns": "sunny"}
        },
        "is_error_tool": False
    },
    {
        "tool_call_id": "2",
        "results": {
            "0": {"get_sunrise_sunset_times_returns": ["6:00 AM", "6:00 PM"]}
        },
        "is_error_tool": False
    }
]</tool_response><|im_end|>
<|im_start|>assistant
<|start_response|>The weather in Krasnodar is sunny, the weather in Moscow is sunny, and the sunrise time in Krasnoyarsk is 6:00 AM.<|end_response|><|im_end|>
```

### Tool Error Handling

*history*
```python
messages = [
  {"role": "user", "content": "Hey dude, what can you do?"},
  {"role": "assistant", "content": "I can provide weather information for a given city and also provide the sunrise and sunset times for a given city."},
  {"role": "user", "content": "Thats great! Okey, can you provide weather in Krasnodar, Moscow and only the sunrise time in Krasnoyarsk for me please."},
  {
      "role": "assistant",
      "tool_plan": "The user has requested weather information for three cities and only the sunrise time for one city. I will first retrieve the weather information for Krasnodar and Moscow, and then retrieve the sunrise time for Krasnoyarsk.",
      "tool_calls": [ 
          {
              "id": "0",
              "type": "function",
              "function": {
                  "name": "get_weather",
                  "arguments": {
                      "city": "Krasnodar"
                  }
              }
          },
          {
              "id": "1",
              "type": "function",
              "function": {
                  "name": "get_weather",
                  "arguments": {
                      "city": "Moscow"
                  }
              }
          },
          {
              "id": "2",
              "type": "function",
              "function": {
                  "name": "get_sunrise_sunset_times",
                  "arguments": {
                      "city": "Krasnoyarsk"
                  }
              }
          },
      ]
  },
  {
      "role": "tool", 
      "tool_call_id": "0",
      "content": { "get_weather_returns": "sunny" }
  },
  {
      "role": "tool", 
      "tool_call_id": "1",
      "content": { "get_weather_returns": "sunny" }
  },
  {
      "role": "tool", 
      "tool_call_id": "2",
      "content": { "get_sunrise_sunset_times_returns": {"error": True, "message": "Server is unavailable now"} },
      "is_error_tool": True
  },
] 
```

*prompt with generation*
```
<|im_start|>system
...grounded_system_prompt...

<|im_end|>
<|im_start|>user
Hey dude, what can you do?<|im_end|>
<|im_start|>assistant
<|start_response|>I can provide weather information for a given city and also provide the sunrise and sunset times for a given city.<|end_response|><|im_end|>
<|im_start|>user
Thats great! Okey, can you provide weather in Krasnodar, Moscow and only the sunrise time in Krasnoyarsk for me please.<|im_end|>
<|im_start|>assistant
<|start_thinking|>The user has requested weather information for three cities and only the sunrise time for one city. I will first retrieve the weather information for Krasnodar and Moscow, and then retrieve the sunrise time for Krasnoyarsk.<|end_thinking|><tool_call>[
    {"tool_call_id": "0", "tool_name": "get_weather", "parameters": {"city": "Krasnodar"}},
    {"tool_call_id": "1", "tool_name": "get_weather", "parameters": {"city": "Moscow"}},
    {"tool_call_id": "2", "tool_name": "get_sunrise_sunset_times", "parameters": {"city": "Krasnoyarsk"}}
]</tool_call><|im_end|>
<|im_start|>system
<tool_response>[
    {
        "tool_call_id": "0",
        "results": {
            "0": {"get_weather_returns": "sunny"}
        },
        "is_error_tool": False
    },
    {
        "tool_call_id": "1",
        "results": {
            "0": {"get_weather_returns": "sunny"}
        },
        "is_error_tool": False
    },
    {
        "tool_call_id": "2",
        "results": {
            "0": {"get_sunrise_sunset_times_returns": {"error": true, "message": "Server is unavailable now"}}
        },
        "is_error_tool": True
    }
]</tool_response><|im_end|>
<|im_start|>assistant
<|start_response|>The weather in Krasnodar and Moscow is sunny. Unfortunately, the server is currently unavailable, so I cannot provide the sunrise time for Krasnoyarsk.<|end_response|><|im_end|>
```

## Limitations <a name="lim"></a>

This is the experimental checkpoint and some hallucinations are possible. If you find something interesting in model behavior, please create [issue and lets discuss it!](https://huggingface.co/Vikhrmodels/Qwen2.5-7B-Instruct-Tool-Planning/discussions) 

* The model the most stability works in `greedy search` or low `temperature(about < 0.5)`
* The model can feel some problems with long user plan. It confuses the trajectory of calls and changes the order in which related tasks are performed. In fact, this is not a mistake, but a violation of the user's requirement.
* The model can solve very easy tasks on the fly, right in the process of calls (for example, basic arithmetic).


## Evaluation <a name="eval"></a>

| Task                      | Acc(%)   |
|---------------------------|----------|
| Simple                    | 73.25    |
| Multiple                  | 93.00    |
| Parallel                  | 90.00    |
| Parallel Multiple         | 81.00    |
| Relevance Detection       | 64.71    |
| Irrelevance Detection     | 85.72    |

## Authors

- [Dmitry Tishencko](https://huggingface.co/DiTy), [Vikhr Team](https://t.me/vikhrlabs)