mistral_common.protocol.instruct.request

@classmethod
def from_openai(
    cls,
    messages: list[dict[str, str | list[dict[str, str | dict[str, Any]]]]],
    tools: list[dict[str, Any]] | None = None,
    continue_final_message: bool = False,
    **kwargs: Any,
) -> "ChatCompletionRequest":
    r"""Create a ChatCompletionRequest from OpenAI ChatCompletion request format.

    Args:
        messages: List of message dicts in OpenAI format. Each dict must have
            a "role" key and optionally "content" or other role-specific fields.
        tools: List of tool dicts in OpenAI format, or `None`. Each tool dict must
            have "type" and "function" keys for function tools.
        continue_final_message: If `True` and the last message is an assistant,
            sets `AssistantMessage.prefix=True` on it.
        **kwargs: Additional request parameters. Supports both OpenAI names
            (e.g., "seed") and mistral-common names (e.g., `random_seed`).
            Cannot specify both "seed" and `random_seed`.

    Returns:
        A ChatCompletionRequest instance with messages and tools converted
        from OpenAI format.

    Raises:
        ValueError: If both "seed" and `random_seed` are specified in kwargs.
    """
    if "seed" in kwargs and "random_seed" in kwargs:
        raise ValueError("Cannot specify both `seed` and `random_seed`.")

    random_seed = kwargs.pop("seed", None)
    if random_seed is None:
        random_seed = kwargs.pop("random_seed", None)

    filtered_kwargs = cls._filter_cls_fields(kwargs)

    converted_messages: list[ChatMessage] = convert_openai_messages(messages)
    converted_messages = _map_continue_final_message(
        messages=converted_messages,
        continue_final_message=TypeAdapter(bool).validate_python(continue_final_message),
    )

    converted_tools = convert_openai_tools(tools) if tools is not None else None

    return cls(
        # Pydantic cannot express the runtime-selected request class's message generic here.
        messages=converted_messages,  # type: ignore[arg-type]
        tools=converted_tools,
        random_seed=random_seed,
        **filtered_kwargs,
    )

def to_openai(
    self,
    reasoning_field_format: ReasoningFieldFormat | None = None,
    **kwargs: Any,
) -> dict[str, Any]:
    r"""Convert this request to OpenAI ChatCompletion API format.

    Args:
        reasoning_field_format: Format for converting thinking/thinking chunks in
            assistant messages to OpenAI's reasoning field. If `None`, uses default.
            See `AssistantMessage.to_openai` for available formats.
        **kwargs: Additional OpenAI-specific parameters to include in the output
            (e.g., stream, temperature, `top_p`). Must not conflict with existing fields.

    Returns:
        Dictionary matching the OpenAI ChatCompletion request schema.

    Raises:
        ValueError: If kwargs contains duplicate or conflicting keys.
        NotImplementedError: If `truncate_for_context_length` is `True` (not implemented).

    Examples:
        >>> from mistral_common.protocol.instruct.messages import UserMessage
        >>> from mistral_common.protocol.instruct.tool_calls import Tool, Function
        >>> request = ChatCompletionRequest(messages=[UserMessage(content="Hello, how are you?")], temperature=0.15)
        >>> request.to_openai(stream=True)
        {'temperature': 0.15, 'top_p': 1.0, 'response_format': {'type': 'text'}, 'continue_final_message': False, 'messages': [{'role': 'user', 'content': 'Hello, how are you?'}], 'tool_choice': 'auto', 'stream': True}
        >>> request = ChatCompletionRequest(messages=[UserMessage(content="Hello, how are you?")], tools=[
        ...     Tool(function=Function(
        ...         name="get_current_weather",
        ...         description="Get the current weather in a given location",
        ...         parameters={
        ...             "type": "object",
        ...             "properties": {
        ...                 "location": {
        ...                     "type": "string",
        ...                     "description": "The city and state, e.g. San Francisco, CA",
        ...                 },
        ...                 "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
        ...             },
        ...             "required": ["location"],
        ...         },
        ...     ),
        ... )])
        >>> request.to_openai()
        {'temperature': 0.7, 'top_p': 1.0, 'response_format': {'type': 'text'}, 'continue_final_message': False, 'messages': [{'role': 'user', 'content': 'Hello, how are you?'}], 'tools': [{'type': 'function', 'function': {'name': 'get_current_weather', 'description': 'Get the current weather in a given location', 'parameters': {'type': 'object', 'properties': {'location': {'type': 'string', 'description': 'The city and state, e.g. San Francisco, CA'}, 'unit': {'type': 'string', 'enum': ['celsius', 'fahrenheit']}}, 'required': ['location']}, 'strict': False}}], 'tool_choice': 'auto'}
    """  # noqa: E501

    # Handle messages and tools separately.
    openai_request: dict[str, Any] = self.model_dump(
        exclude={"messages", "tools", "truncate_for_context_length", "tool_choice"}, exclude_none=True
    )

    # Rename random_seed to seed.
    seed = openai_request.pop("random_seed", None)
    if seed is not None:
        openai_request["seed"] = seed

    reasoning_effort = openai_request.pop("reasoning_effort", None)
    openai_request["continue_final_message"] = bool(
        self.messages and isinstance(self.messages[-1], AssistantMessage) and self.messages[-1].prefix
    )
    if reasoning_effort is not None:
        openai_request["reasoning_effort"] = reasoning_effort

    if self.truncate_for_context_length:
        raise NotImplementedError("Truncating for context length is not implemented for OpenAI requests.")

    for kwarg in kwargs:
        if kwarg in openai_request:
            raise ValueError(f"Duplicate keyword argument: {kwarg}")
        elif kwarg in ChatCompletionRequest.model_fields:
            raise ValueError(f"Keyword argument {kwarg} is already set in the request.")

    openai_messages = []
    for message in self.messages:
        if isinstance(message, AssistantMessage):
            openai_messages.append(message.to_openai(reasoning_field_format=reasoning_field_format))
        else:
            openai_messages.append(message.to_openai())

    openai_request["messages"] = openai_messages
    if self.tools is not None:
        openai_request["tools"] = [tool.to_openai() for tool in self.tools]

    openai_tool_choice: str | dict[str, Any]
    match self.tool_choice:
        case ToolChoiceEnum.auto | ToolChoiceEnum.none:
            openai_tool_choice = self.tool_choice
        case ToolChoiceEnum.required | ToolChoiceEnum.any:
            openai_tool_choice = ToolChoiceEnum.required.value
        case _:
            openai_tool_choice = self.tool_choice.model_dump()

    openai_request["tool_choice"] = openai_tool_choice

    openai_request.update(kwargs)

    return openai_request

@staticmethod
def none() -> "ModelSettings":
    r"""Create a ModelSettings instance with all fields set to `None`.

    Returns:
        ModelSettings with `reasoning_effort=None`.
    """
    return ModelSettings()