Skip to content

mistral_common.protocol.instruct.validator

MistralRequestValidator(mode=ValidationMode.test)

Bases: Generic[UserMessageType, AssistantMessageType, ToolMessageType, SystemMessageType]

Validates Mistral chat completion requests and messages.

Performs comprehensive validation of request structure, message content, tool definitions, and model settings according to the specified validation mode.

Examples:

>>> from mistral_common.protocol.instruct.messages import UserMessage, AssistantMessage
>>> validator = MistralRequestValidator()
>>> messages = [UserMessage(content="Hello how are you ?")]
>>> validator.validate_messages(messages)

Parameters:

Name Type Description Default
mode ValidationMode

The validation mode to use. Options: - ValidationMode.serving: Strict production validation - ValidationMode.finetuning: Finetuning-specific validation - ValidationMode.test: Lenient testing validation (default) - ValidationMode.agnostic: Pipeline-agnostic validation that applies all content checks without terminal-role rules

 test
Source code in src/mistral_common/protocol/instruct/validator.py 
121
122
123
124
125
126
127
128
129
130
131
132
def __init__(self, mode: ValidationMode = ValidationMode.test):
    r"""Initialize the MistralRequestValidator.

    Args:
        mode: The validation mode to use. Options:
            - `ValidationMode.serving`: Strict production validation
            - `ValidationMode.finetuning`: Finetuning-specific validation
            - `ValidationMode.test`: Lenient testing validation (default)
            - `ValidationMode.agnostic`: Pipeline-agnostic validation that
                applies all content checks without terminal-role rules
    """
    self._mode = mode

mode property

The validation mode this validator enforces.

Returns:

Type Description
ValidationMode

The ValidationMode (serving, finetuning, test, or agnostic) this
ValidationMode

instance was constructed with.

validate_messages(messages)

Validate a list of messages.

Checks message structure (alternating user/assistant, valid roles) and content (valid chunk types for each role, valid tool calls, etc.).

Parameters:

Name Type Description Default
messages list[UATS]

List of message objects to validate. Each message must be a subclass of BaseMessage with a valid role.

 required

Raises:

Type Description
InvalidMessageStructureException

If message structure is invalid (e.g., consecutive assistant messages without intervening user message).
InvalidUserMessageException

If a user message has invalid content.
InvalidAssistantMessageException

If an assistant message has invalid content.
InvalidToolMessageException

If a tool message has invalid content.
InvalidSystemPromptException

If a system message has invalid content.
InvalidToolCallException

If a tool call in an assistant message is invalid.

Examples:

>>> from mistral_common.protocol.instruct.messages import UserMessage, AssistantMessage
>>> validator = MistralRequestValidator()
>>> messages = [AssistantMessage(content="Hi"), UserMessage(content="Hello")]
>>> validator.validate_messages(messages)
Source code in src/mistral_common/protocol/instruct/validator.py 
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
def validate_messages(self, messages: list[UATS]) -> None:
    r"""Validate a list of messages.

    Checks message structure (alternating user/assistant, valid roles) and
    content (valid chunk types for each role, valid tool calls, etc.).

    Args:
        messages: List of message objects to validate. Each message must be
            a subclass of BaseMessage with a valid role.

    Raises:
        InvalidMessageStructureException: If message structure is invalid
            (e.g., consecutive assistant messages without intervening user message).
        InvalidUserMessageException: If a user message has invalid content.
        InvalidAssistantMessageException: If an assistant message has invalid content.
        InvalidToolMessageException: If a tool message has invalid content.
        InvalidSystemPromptException: If a system message has invalid content.
        InvalidToolCallException: If a tool call in an assistant message is invalid.

    Examples:
        >>> from mistral_common.protocol.instruct.messages import UserMessage, AssistantMessage
        >>> validator = MistralRequestValidator()
        >>> messages = [AssistantMessage(content="Hi"), UserMessage(content="Hello")]
        >>> validator.validate_messages(messages)
    """
    self._validate_message_list_structure(messages)
    self._validate_message_list_content(messages)

validate_request(request)

Validate a complete ChatCompletionRequest.

Performs full validation including: - Model field (required in serving mode) - Message list structure and content - Tool definitions and tool calls - Model settings

Parameters:

Name Type Description Default
request ChatCompletionRequest

The ChatCompletionRequest to validate.

 required

Returns:

Type Description
The same request object after validation. Note

validation may mutate
ChatCompletionRequest[UATS]

the request in-place for some normalizations.

Raises:

Type Description
InvalidRequestException

If request fails validation (missing model in serving mode, invalid messages, invalid tools, etc.).

Examples:

>>> from mistral_common.protocol.instruct.messages import UserMessage
>>> validator = MistralRequestValidator()
>>> request = ChatCompletionRequest(messages=[UserMessage(content="Hello")])
>>> validated_request = validator.validate_request(request)
Source code in src/mistral_common/protocol/instruct/validator.py 
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
def validate_request(self, request: ChatCompletionRequest) -> ChatCompletionRequest[UATS]:
    r"""Validate a complete ChatCompletionRequest.

    Performs full validation including:
    - Model field (required in serving mode)
    - Message list structure and content
    - Tool definitions and tool calls
    - Model settings

    Args:
        request: The ChatCompletionRequest to validate.

    Returns:
        The same request object after validation. Note: validation may mutate
        the request in-place for some normalizations.

    Raises:
        InvalidRequestException: If request fails validation (missing model in
            serving mode, invalid messages, invalid tools, etc.).

    Examples:
        >>> from mistral_common.protocol.instruct.messages import UserMessage
        >>> validator = MistralRequestValidator()
        >>> request = ChatCompletionRequest(messages=[UserMessage(content="Hello")])
        >>> validated_request = validator.validate_request(request)
    """

    if self._mode == ValidationMode.serving:
        if request.model is None:
            raise InvalidRequestException("Model name parameter is required for serving mode")

    # Validate the messages
    self.validate_messages(request.messages)

    # Validate the tools
    self._validate_tools(request.tools or [])

    self._validate_model_settings(request)

    return request

MistralRequestValidatorV11(mode=ValidationMode.test)

Bases: MistralRequestValidatorV5

Validator for v11 Mistral requests.

This validator extends v5 functionality by: - Adding stricter tool call/result pairing validation. - Allowing thinking chunks in assistant messages. - Allowing system prompts with audio chunks

Source code in src/mistral_common/protocol/instruct/validator.py 
121
122
123
124
125
126
127
128
129
130
131
132
def __init__(self, mode: ValidationMode = ValidationMode.test):
    r"""Initialize the MistralRequestValidator.

    Args:
        mode: The validation mode to use. Options:
            - `ValidationMode.serving`: Strict production validation
            - `ValidationMode.finetuning`: Finetuning-specific validation
            - `ValidationMode.test`: Lenient testing validation (default)
            - `ValidationMode.agnostic`: Pipeline-agnostic validation that
                applies all content checks without terminal-role rules
    """
    self._mode = mode

MistralRequestValidatorV13(mode=ValidationMode.test)

Bases: MistralRequestValidatorV11

Validator for v13 Mistral requests.

Source code in src/mistral_common/protocol/instruct/validator.py 
121
122
123
124
125
126
127
128
129
130
131
132
def __init__(self, mode: ValidationMode = ValidationMode.test):
    r"""Initialize the MistralRequestValidator.

    Args:
        mode: The validation mode to use. Options:
            - `ValidationMode.serving`: Strict production validation
            - `ValidationMode.finetuning`: Finetuning-specific validation
            - `ValidationMode.test`: Lenient testing validation (default)
            - `ValidationMode.agnostic`: Pipeline-agnostic validation that
                applies all content checks without terminal-role rules
    """
    self._mode = mode

MistralRequestValidatorV15(mode=ValidationMode.test)

Bases: MistralRequestValidatorV13

Validator for v15 Mistral requests.

Source code in src/mistral_common/protocol/instruct/validator.py 
121
122
123
124
125
126
127
128
129
130
131
132
def __init__(self, mode: ValidationMode = ValidationMode.test):
    r"""Initialize the MistralRequestValidator.

    Args:
        mode: The validation mode to use. Options:
            - `ValidationMode.serving`: Strict production validation
            - `ValidationMode.finetuning`: Finetuning-specific validation
            - `ValidationMode.test`: Lenient testing validation (default)
            - `ValidationMode.agnostic`: Pipeline-agnostic validation that
                applies all content checks without terminal-role rules
    """
    self._mode = mode

MistralRequestValidatorV3(mode=ValidationMode.test)

Bases: MistralRequestValidator

Validator for v3 Mistral requests.

This validator adds additional validation for tool call IDs.

Examples:

>>> validator = MistralRequestValidatorV3()
Source code in src/mistral_common/protocol/instruct/validator.py 
121
122
123
124
125
126
127
128
129
130
131
132
def __init__(self, mode: ValidationMode = ValidationMode.test):
    r"""Initialize the MistralRequestValidator.

    Args:
        mode: The validation mode to use. Options:
            - `ValidationMode.serving`: Strict production validation
            - `ValidationMode.finetuning`: Finetuning-specific validation
            - `ValidationMode.test`: Lenient testing validation (default)
            - `ValidationMode.agnostic`: Pipeline-agnostic validation that
                applies all content checks without terminal-role rules
    """
    self._mode = mode

MistralRequestValidatorV5(mode=ValidationMode.test)

Bases: MistralRequestValidatorV3

Validator for v5 Mistral requests.

This validator allows for both tool calls and content in the assistant message.

Note

For requests containing audio, this validator ensures that no system prompt is present.

Examples:

>>> validator = MistralRequestValidatorV5()
Source code in src/mistral_common/protocol/instruct/validator.py 
121
122
123
124
125
126
127
128
129
130
131
132
def __init__(self, mode: ValidationMode = ValidationMode.test):
    r"""Initialize the MistralRequestValidator.

    Args:
        mode: The validation mode to use. Options:
            - `ValidationMode.serving`: Strict production validation
            - `ValidationMode.finetuning`: Finetuning-specific validation
            - `ValidationMode.test`: Lenient testing validation (default)
            - `ValidationMode.agnostic`: Pipeline-agnostic validation that
                applies all content checks without terminal-role rules
    """
    self._mode = mode

ValidationMode

Bases: str, Enum

Validation mode controlling which validation rules are applied.

Attributes:

Name Type Description
serving

Strict validation for production serving. Requires model to be specified and enforces all constraints.
finetuning

Validation for finetuning scenarios. May allow some fields that are not allowed in serving mode.
test

Lenient validation for testing. Skips some production constraints.
agnostic

Pipeline-agnostic validation. Applies all content checks without assuming a downstream pipeline, so no terminal-role rule is enforced.

Examples:

>>> mode = ValidationMode.serving

get_validator(version, mode)

Get the appropriate validator for a given tokenizer version and validation mode.

The validator version matches the tokenizer version and enforces the content chunk types, tool call ID rules, and model settings supported by that version.

Parameters:

Name Type Description Default
version TokenizerVersion

The tokenizer version the validator should match.

 required
mode ValidationMode

The validation mode (serving, finetuning, test, or agnostic) controlling which constraints are enforced.

 required

Returns:

Type Description
MistralRequestValidator

The validator instance appropriate for the version and mode.
Source code in src/mistral_common/protocol/instruct/validator.py 
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
def get_validator(version: TokenizerVersion, mode: ValidationMode) -> MistralRequestValidator:
    r"""Get the appropriate validator for a given tokenizer version and validation mode.

    The validator version matches the tokenizer version and enforces the
    content chunk types, tool call ID rules, and model settings supported by
    that version.

    Args:
        version: The tokenizer version the validator should match.
        mode: The validation mode (serving, finetuning, test, or agnostic)
            controlling which constraints are enforced.

    Returns:
        The validator instance appropriate for the version and mode.
    """
    validator: MistralRequestValidator
    match version:
        case TokenizerVersion.v1 | TokenizerVersion.v2:
            validator = MistralRequestValidator(mode=mode)
        case TokenizerVersion.v3:
            validator = MistralRequestValidatorV3(mode=mode)
        case TokenizerVersion.v7:
            validator = MistralRequestValidatorV5(mode=mode)
        case TokenizerVersion.v11:
            validator = MistralRequestValidatorV11(mode=mode)
        case TokenizerVersion.v13:
            validator = MistralRequestValidatorV13(mode=mode)
        case TokenizerVersion.v15:
            validator = MistralRequestValidatorV15(mode=mode)
        case _:
            assert_never(f"Unsupported tokenizer version: {version}")

    return validator