Parsers

from rllm.parser import ToolParser

tool_calls = parser.parse(model_response)

prompt = parser.get_tool_prompt(tools_schema)

parser = ToolParser.get_parser(tokenizer)

from rllm.parser import R1ToolParser

parser = R1ToolParser()

<|tool_calls_begin|>
<|tool_call_begin|>function<|tool_sep|>function_name
{"param1": "value1", "param2": "value2"}
<|tool_call_end|>
<|tool_calls_end|>

tool_calls = parser.parse(model_response)
prompt = parser.get_tool_prompt(tools_schema)

from rllm.parser import QwenToolParser

parser = QwenToolParser()

<tool_call>{"name": "function_name", "arguments": {...}}</tool_call>

tool_calls = parser.parse(model_response)
prompt = parser.get_tool_prompt(tools_schema)

from rllm.parser import ChatTemplateParser

parser = ChatTemplateParser.get_parser(tokenizer)

tokens = parser.apply_chat_template(
    messages,
    add_generation_prompt=True
)

text = parser.decode(tokens)

from rllm.parser import R1ToolParser
from rllm.tools import ToolCall

parser = R1ToolParser()

model_response = """
<|tool_calls_begin|>
<|tool_call_begin|>function<|tool_sep|>search_web
{"query": "What is rLLM?", "num_results": 5}
<|tool_call_end|>
<|tool_calls_end|>
"""

tool_calls = parser.parse(model_response)

for call in tool_calls:
    print(f"Tool: {call.name}")
    print(f"Arguments: {call.arguments}")

# Output:
# Tool: search_web
# Arguments: {'query': 'What is rLLM?', 'num_results': 5}

from rllm.parser import QwenToolParser

parser = QwenToolParser()

model_response = '''
Let me search for that information.
<tool_call>{"name": "search", "arguments": {"query": "capital of France"}}</tool_call>
'''

tool_calls = parser.parse(model_response)

for call in tool_calls:
    print(f"Tool: {call.name}")
    print(f"Arguments: {call.arguments}")

# Output:
# Tool: search
# Arguments: {'query': 'capital of France'}

from rllm.parser import QwenToolParser

parser = QwenToolParser()

model_response = '''
<tool_call>{"name": "calculator", "arguments": {"a": 5, "b": 3, "op": "add"}}</tool_call>
<tool_call>{"name": "calculator", "arguments": {"a": 10, "b": 2, "op": "multiply"}}</tool_call>
'''

tool_calls = parser.parse(model_response)

print(f"Found {len(tool_calls)} tool calls")
for i, call in enumerate(tool_calls):
    print(f"\nCall {i+1}:")
    print(f"  Name: {call.name}")
    print(f"  Args: {call.arguments}")

from rllm.parser import R1ToolParser
import json

parser = R1ToolParser()

tools_schema = json.dumps([
    {
        "type": "function",
        "function": {
            "name": "search_web",
            "description": "Search the web for information",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Search query"}
                },
                "required": ["query"]
            }
        }
    }
], indent=2)

tool_prompt = parser.get_tool_prompt(tools_schema)

print(tool_prompt)
# Outputs formatted tool prompt with instructions

from transformers import AutoTokenizer
from rllm.parser import ToolParser

# DeepSeek model -> R1ToolParser
tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B")
parser = ToolParser.get_parser(tokenizer)
print(type(parser).__name__)  # R1ToolParser

# Qwen model -> QwenToolParser
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-4B")
parser = ToolParser.get_parser(tokenizer)
print(type(parser).__name__)  # QwenToolParser

from transformers import AutoTokenizer
from rllm.parser import ToolParser

tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-4B")
parser = ToolParser.get_parser(tokenizer)

# Parse a model response into structured tool calls.
response = """<tool_call>
{"name": "search", "arguments": {"query": "rllm"}}
</tool_call>"""

tool_calls = parser.parse(response)
for tc in tool_calls:
    print(tc.name, tc.arguments)

from transformers import AutoTokenizer
from rllm.parser import ChatTemplateParser

tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B")
parser = ChatTemplateParser.get_parser(tokenizer)

messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "What is 2+2?"}
]

# Convert to tokens
tokens = parser.apply_chat_template(
    messages,
    add_generation_prompt=True,
    return_tensors="pt"
)

print(f"Tokens: {tokens}")

# Decode back to text
text = parser.decode(tokens[0])
print(f"Formatted: {text}")