Skip to content

vllm_mlx.tool_parsers.xlam_tool_parser

xLAM tool call parser for vllm-mlx.

View the complete module source at #L1-L177.

API details

Each callable below includes its exact signature, type annotations, inputs, defaults, return contract, documented exceptions, implementation source, and parsed docstring sections when the source provides them.

vllm_mlx.tool_parsers.xlam_tool_parser

xLAM tool call parser for vllm-mlx.

Handles Salesforce xLAM models' tool calling format which supports: - JSON arrays of tool calls - Tool calls in markdown code blocks - Tool calls after reasoning blocks

vllm_mlx.tool_parsers.xlam_tool_parser.xLAMToolParser 

xLAMToolParser(tokenizer: PreTrainedTokenizerBase | None = None)

Bases: ToolParser

Tool call parser for Salesforce xLAM models.

Supports multiple formats: - JSON array: [{"name": "func", "arguments": {...}}] - Markdown code blocks: json [...] - After thinking: [...]

Used when --enable-auto-tool-choice --tool-call-parser xlam are set.

Source code in vllm_mlx/tool_parsers/abstract_tool_parser.py 
103
104
105
106
107
108
109
110
111
112
113
def __init__(self, tokenizer: PreTrainedTokenizerBase | None = None):
    """
    Initialize the tool parser.

    Args:
        tokenizer: The tokenizer for the model (optional, some parsers need it)
    """
    self.model_tokenizer = tokenizer
    # State for streaming parsing
    self.current_tool_id: int = -1
    self.prev_tool_call_arr: list[dict] = []

vllm_mlx.tool_parsers.xlam_tool_parser.xLAMToolParser.CODE_BLOCK_PATTERN class-attribute instance-attribute 

CODE_BLOCK_PATTERN = re.compile('```(?:json)?\\s*([\\s\\S]*?)```')

vllm_mlx.tool_parsers.xlam_tool_parser.xLAMToolParser.THINKING_PATTERN class-attribute instance-attribute 

THINKING_PATTERN = re.compile('</think>\\s*([\\s\\S]*)')

vllm_mlx.tool_parsers.xlam_tool_parser.xLAMToolParser.TOOL_CALLS_TAG_PATTERN class-attribute instance-attribute 

TOOL_CALLS_TAG_PATTERN = re.compile('\\[TOOL_CALLS\\]([\\s\\S]*?)(?:\\n|$)')

vllm_mlx.tool_parsers.xlam_tool_parser.xLAMToolParser._try_extract_json 

_try_extract_json(text: str) -> tuple[str | None, list | None]

Try to extract JSON tool calls from text.

Returns:

  • tuple[str | None, list | None] –

    Tuple of (content, tool_calls_list)

Source code in vllm_mlx/tool_parsers/xlam_tool_parser.py 
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
def _try_extract_json(self, text: str) -> tuple[str | None, list | None]:
    """
    Try to extract JSON tool calls from text.

    Returns:
        Tuple of (content, tool_calls_list)
    """
    # Try markdown code blocks
    for pattern in [
        self.CODE_BLOCK_PATTERN,
        self.TOOL_CALLS_TAG_PATTERN,
    ]:
        matches = pattern.findall(text)
        for match in matches:
            try:
                parsed = json.loads(match.strip())
                if isinstance(parsed, list):
                    content = pattern.sub("", text).strip()
                    return content if content else None, parsed
            except json.JSONDecodeError:
                continue

    # Try after </think> tag
    thinking_match = self.THINKING_PATTERN.search(text)
    if thinking_match:
        after_think = thinking_match.group(1).strip()
        try:
            parsed = json.loads(after_think)
            if isinstance(parsed, list):
                content = text[: thinking_match.start() + len("</think>")].strip()
                return content if content else None, parsed
        except json.JSONDecodeError:
            pass

    # Try entire text as JSON array
    text = text.strip()
    if text.startswith("["):
        try:
            parsed = json.loads(text)
            if isinstance(parsed, list):
                return None, parsed
        except json.JSONDecodeError:
            pass

    return text, None

vllm_mlx.tool_parsers.xlam_tool_parser.xLAMToolParser.extract_tool_calls 

extract_tool_calls(model_output: str, request: dict[str, Any] | None = None) -> ExtractedToolCallInformation

Extract tool calls from xLAM model output.

Source code in vllm_mlx/tool_parsers/xlam_tool_parser.py 
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
def extract_tool_calls(
    self, model_output: str, request: dict[str, Any] | None = None
) -> ExtractedToolCallInformation:
    """
    Extract tool calls from xLAM model output.
    """
    content, tool_calls_data = self._try_extract_json(model_output)

    if not tool_calls_data:
        return ExtractedToolCallInformation(
            tools_called=False, tool_calls=[], content=content or model_output
        )

    tool_calls = []
    for call in tool_calls_data:
        if isinstance(call, dict) and "name" in call:
            args = call.get("arguments", call.get("parameters", {}))
            tool_calls.append(
                {
                    "id": generate_tool_id(),
                    "name": call["name"],
                    "arguments": (
                        json.dumps(args, ensure_ascii=False)
                        if isinstance(args, dict)
                        else str(args)
                    ),
                }
            )

    if tool_calls:
        return ExtractedToolCallInformation(
            tools_called=True,
            tool_calls=tool_calls,
            content=content,
        )

    return ExtractedToolCallInformation(
        tools_called=False, tool_calls=[], content=model_output
    )

vllm_mlx.tool_parsers.xlam_tool_parser.xLAMToolParser.extract_tool_calls_streaming 

extract_tool_calls_streaming(previous_text: str, current_text: str, delta_text: str, previous_token_ids: Sequence[int] | None = None, current_token_ids: Sequence[int] | None = None, delta_token_ids: Sequence[int] | None = None, request: dict[str, Any] | None = None) -> dict[str, Any] | None

Extract tool calls from streaming xLAM model output.

Source code in vllm_mlx/tool_parsers/xlam_tool_parser.py 
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
def extract_tool_calls_streaming(
    self,
    previous_text: str,
    current_text: str,
    delta_text: str,
    previous_token_ids: Sequence[int] | None = None,
    current_token_ids: Sequence[int] | None = None,
    delta_token_ids: Sequence[int] | None = None,
    request: dict[str, Any] | None = None,
) -> dict[str, Any] | None:
    """
    Extract tool calls from streaming xLAM model output.
    """
    # Check for any indicators of tool calls
    markers = ["```", "[TOOL_CALLS]", "</think>"]
    has_marker = any(m in current_text for m in markers)

    # Also check for JSON array start
    stripped = current_text.strip()
    if stripped.startswith("[") and "{" in stripped:
        has_marker = True

    if not has_marker:
        return {"content": delta_text}

    # Try to parse when we see completion markers
    if "]" in delta_text or "```" in delta_text:
        result = self.extract_tool_calls(current_text)
        if result.tools_called:
            return {
                "tool_calls": [
                    {
                        "index": i,
                        "id": tc["id"],
                        "type": "function",
                        "function": {
                            "name": tc["name"],
                            "arguments": tc["arguments"],
                        },
                    }
                    for i, tc in enumerate(result.tool_calls)
                ]
            }

    return None

vllm_mlx.tool_parsers.xlam_tool_parser.generate_tool_id 

generate_tool_id() -> str

Generate a unique tool call ID.

Source code in vllm_mlx/tool_parsers/xlam_tool_parser.py 
24
25
26
def generate_tool_id() -> str:
    """Generate a unique tool call ID."""
    return f"call_{uuid.uuid4().hex[:8]}"

Complete contract reference

Expand any definition for its exact inputs, annotations, defaults, return contract, directly raised exceptions, source-grounded behavior, and immutable line link. This section includes private and nested definitions that ordinary API generators omit.

vllm_mlx.tool_parsers.xlam_tool_parser.generate_tool_id · function 
vllm_mlx.tool_parsers.xlam_tool_parser.generate_tool_id() -> str

Generate a unique tool call ID.

Parameters

This callable has no explicit inputs.

Returns

  • Type: str
  • Direct return expressions: f'call_{uuid.uuid4().hex[:8]}'

Exceptions and behavior

Function generate_tool_id calls uuid.uuid4; returns f'call_{uuid.uuid4().hex[:8]}'. No direct raise statement appears in this definition.

View source #L24-L26.

vllm_mlx.tool_parsers.xlam_tool_parser.xLAMToolParser · class 
vllm_mlx.tool_parsers.xlam_tool_parser.xLAMToolParser()

Tool call parser for Salesforce xLAM models.

Parameters

This callable has no explicit inputs.

Returns

  • Constructs: vllm_mlx.tool_parsers.xlam_tool_parser.xLAMToolParser

Exceptions and behavior

Class xLAMToolParser derives from ToolParser and declares 3 direct member(s). No direct raise statement appears in this definition.

View source #L30-L177.

vllm_mlx.tool_parsers.xlam_tool_parser.xLAMToolParser._try_extract_json · method 
vllm_mlx.tool_parsers.xlam_tool_parser.xLAMToolParser._try_extract_json(text: str) -> tuple[str | None, list | None]

Try to extract JSON tool calls from text.

Parameters

Name Type Required Default Description
text str yes none Required positional or keyword input.

Returns

  • Type: tuple[str | None, list | None]
  • Direct return expressions: (content if content else None, parsed); (None, parsed); (text, None)

Exceptions and behavior

Method xLAMToolParser._try_extract_json calls pattern.findall, json.loads, match.strip, isinstance; has 3 explicit return paths. No direct raise statement appears in this definition.

View source #L47-L91.

vllm_mlx.tool_parsers.xlam_tool_parser.xLAMToolParser.extract_tool_calls · method 
vllm_mlx.tool_parsers.xlam_tool_parser.xLAMToolParser.extract_tool_calls(model_output: str, request: dict[str, Any] | None = None) -> ExtractedToolCallInformation

Extract tool calls from xLAM model output.

Parameters

Name Type Required Default Description
model_output str yes none Required positional or keyword input.
request dict[str, Any] \| None no None Optional positional or keyword input; defaults to None.

Returns

  • Type: ExtractedToolCallInformation
  • Direct return expressions: ExtractedToolCallInformation(tools_called=False, tool_calls=[], content=content or model_output); ExtractedToolCallInformation(tools_called=True, tool_calls=tool_calls, content=content); ExtractedToolCallInformation(tools_called=False, tool_calls=[], content=model_output)

Exceptions and behavior

Method xLAMToolParser.extract_tool_calls calls self._try_extract_json, ExtractedToolCallInformation, isinstance, call.get; has 3 explicit return paths. No direct raise statement appears in this definition.

View source #L93-L131.

vllm_mlx.tool_parsers.xlam_tool_parser.xLAMToolParser.extract_tool_calls_streaming · method 
vllm_mlx.tool_parsers.xlam_tool_parser.xLAMToolParser.extract_tool_calls_streaming(previous_text: str, current_text: str, delta_text: str, previous_token_ids: Sequence[int] | None = None, current_token_ids: Sequence[int] | None = None, delta_token_ids: Sequence[int] | None = None, request: dict[str, Any] | None = None) -> dict[str, Any] | None

Extract tool calls from streaming xLAM model output.

Parameters

Name Type Required Default Description
previous_text str yes none Required positional or keyword input.
current_text str yes none Required positional or keyword input.
delta_text str yes none Required positional or keyword input.
previous_token_ids Sequence[int] \| None no None Optional positional or keyword input; defaults to None.
current_token_ids Sequence[int] \| None no None Optional positional or keyword input; defaults to None.
delta_token_ids Sequence[int] \| None no None Optional positional or keyword input; defaults to None.
request dict[str, Any] \| None no None Optional positional or keyword input; defaults to None.

Returns

  • Type: dict[str, Any] | None
  • Direct return expressions: {'content': delta_text}; {'tool_calls': [{'index': i, 'id': tc['id'], 'type': 'function', 'function': {'name': tc['name'], 'arguments': tc['argu…; None

Exceptions and behavior

Method xLAMToolParser.extract_tool_calls_streaming calls any, current_text.strip, stripped.startswith, self.extract_tool_calls; has 3 explicit return paths. No direct raise statement appears in this definition.

View source #L133-L177.

Complete symbol map

This map also includes private definitions and nested helpers. The signature column exposes every explicit input even when an internal helper has no dedicated parameter prose.

Symbol Kind Signature and inputs What it does Source
generate_tool_id function generate_tool_id() -> str Generate a unique tool call ID. #L24-L26
xLAMToolParser class xLAMToolParser() Tool call parser for Salesforce xLAM models. #L30-L177
xLAMToolParser._try_extract_json method xLAMToolParser._try_extract_json(text: str) -> tuple[str \| None, list \| None] Try to extract JSON tool calls from text. #L47-L91
xLAMToolParser.extract_tool_calls method xLAMToolParser.extract_tool_calls(model_output: str, request: dict[str, Any] \| None = None) -> ExtractedToolCallInformation Extract tool calls from xLAM model output. #L93-L131
xLAMToolParser.extract_tool_calls_streaming method xLAMToolParser.extract_tool_calls_streaming(previous_text: str, current_text: str, delta_text: str, previous_token_ids: Sequence[int] \| None = None, current_token_ids: Sequence[int] \| None = None, delta_token_ids: Sequence[int] \| None = None, request: dict[str, Any] \| None = None) -> dict[str, Any] \| None Extract tool calls from streaming xLAM model output. #L133-L177