mirascope 1.25.7__py3-none-any.whl → 2.0.0a0__py3-none-any.whl

mirascope/core/mistral/_utils/_convert_message_params.py

@@ -1,122 +0,0 @@
-"""Utility for converting `BaseMessageParam` to `ChatMessage`."""
-
-import base64
-
-from mistralai.models import (
-    AssistantMessage,
-    FunctionCall,
-    ImageURL,
-    ImageURLChunk,
-    SystemMessage,
-    TextChunk,
-    ToolCall,
-    ToolMessage,
-    UserMessage,
-)
-
-from ...base import BaseMessageParam
-
-
-def _make_message(
-    role: str,
-    **kwargs,  # noqa: ANN003
-) -> AssistantMessage | SystemMessage | ToolMessage | UserMessage:
-    if role == "assistant":
-        return AssistantMessage(**kwargs)
-    elif role == "system":
-        return SystemMessage(**kwargs)
-    elif role == "tool":
-        return ToolMessage(**kwargs)
-    elif role == "user":
-        return UserMessage(**kwargs)
-    raise ValueError(f"Invalid role: {role}")
-
-
-def convert_message_params(
-    message_params: list[
-        BaseMessageParam | AssistantMessage | SystemMessage | ToolMessage | UserMessage
-    ],
-) -> list[AssistantMessage | SystemMessage | ToolMessage | UserMessage]:
-    converted_message_params = []
-    for message_param in message_params:
-        if not isinstance(message_param, BaseMessageParam):
-            converted_message_params.append(message_param)
-        elif isinstance(content := message_param.content, str):
-            converted_message_params.append(_make_message(**message_param.model_dump()))
-        else:
-            converted_content = []
-            for part in content:
-                if part.type == "text":
-                    converted_content.append(TextChunk(text=part.text))
-
-                elif part.type == "image":
-                    if part.media_type not in [
-                        "image/jpeg",
-                        "image/png",
-                        "image/gif",
-                        "image/webp",
-                    ]:
-                        raise ValueError(
-                            f"Unsupported image media type: {part.media_type}. Mistral"
-                            " currently only supports JPEG, PNG, GIF, and WebP images."
-                        )
-                    data = base64.b64encode(part.image).decode("utf-8")
-                    converted_content.append(
-                        ImageURLChunk(
-                            image_url=ImageURL(
-                                url=f"data:{part.media_type};base64,{data}",
-                                detail=part.detail if part.detail else "auto",
-                            )
-                        )
-                    )
-                elif part.type == "image_url":
-                    converted_content.append(
-                        {
-                            "type": "image_url",
-                            "image_url": part.url,
-                        }
-                    )
-                elif part.type == "tool_call":
-                    converted_message_params.append(
-                        AssistantMessage(
-                            role="assistant",
-                            content=converted_content if converted_content else None,
-                            tool_calls=[
-                                ToolCall(
-                                    function=FunctionCall(
-                                        name=part.name,
-                                        arguments=part.args,  # pyright: ignore [reportArgumentType]
-                                    ),
-                                    id=part.id,
-                                    type="function",
-                                ),
-                            ],
-                        )
-                    )
-                    converted_content = []
-                elif part.type == "tool_result":
-                    if converted_content:
-                        converted_message_params.append(
-                            _make_message(
-                                role=message_param.role, content=converted_content
-                            )
-                        )
-                        converted_content = []
-                    converted_message_params.append(
-                        ToolMessage(
-                            role="tool",
-                            content=part.content,
-                            tool_call_id=part.id,
-                            name=part.name,
-                        )
-                    )
-                else:
-                    raise ValueError(
-                        "Mistral currently only supports text and image parts. "
-                        f"Part provided: {part.type}"
-                    )
-            if converted_content:
-                converted_message_params.append(
-                    _make_message(role=message_param.role, content=converted_content)
-                )
-    return converted_message_params

mirascope/core/mistral/_utils/_get_json_output.py

@@ -1,34 +0,0 @@
-"""Get the JSON output from a completion response."""
-
-from typing import cast
-
-from ..call_response import MistralCallResponse
-from ..call_response_chunk import MistralCallResponseChunk
-
-
-def get_json_output(
-    response: MistralCallResponse | MistralCallResponseChunk, json_mode: bool
-) -> str:
-    """Get the JSON output from a completion response."""
-    if isinstance(response, MistralCallResponse):
-        if json_mode and response.content:
-            return response.content
-        elif (
-            (choices := response.response.choices)
-            and choices
-            and (tool_calls := choices[0].message.tool_calls)
-        ):
-            return cast(str, tool_calls[0].function.arguments)
-        raise ValueError("No tool call or JSON object found in response.")
-    else:
-        # raise ValueError("Mistral does not support structured streaming... :(")
-        if json_mode:
-            return response.content
-        elif (
-            (choices := response.chunk.choices)
-            and (tool_calls := choices[0].delta.tool_calls)
-            and (function := tool_calls[0].function)
-            and (arguments := function.arguments) is not None
-        ):
-            return cast(str, arguments)
-        return ""

mirascope/core/mistral/_utils/_handle_stream.py

@@ -1,139 +0,0 @@
-"""Handles the stream of completion chunks."""
-
-from collections.abc import AsyncGenerator, Generator
-from typing import cast
-
-from mistralai.models import (
-    CompletionEvent,
-    FunctionCall,
-    ToolCall,
-)
-
-from ..call_response_chunk import MistralCallResponseChunk
-from ..tool import MistralTool
-
-
-def _handle_chunk(
-    chunk: CompletionEvent,
-    current_tool_call: ToolCall,
-    current_tool_type: type[MistralTool] | None,
-    tool_types: list[type[MistralTool]] | None,
-) -> tuple[
-    MistralTool | None,
-    ToolCall,
-    type[MistralTool] | None,
-]:
-    """Handles a chunk of the stream."""
-    if not tool_types or not (tool_calls := chunk.data.choices[0].delta.tool_calls):
-        return None, current_tool_call, current_tool_type
-
-    tool_call = tool_calls[0]
-    # Reset on new tool
-    if tool_call.id != "null" and tool_call.function is not None:
-        previous_tool_call = current_tool_call.model_copy()
-        previous_tool_type = current_tool_type
-        current_tool_call = ToolCall(
-            id=tool_call.id,
-            function=FunctionCall(
-                arguments="",
-                name=tool_call.function.name if tool_call.function.name else "",
-            ),
-            type="function",
-        )
-        current_tool_type = None
-        for tool_type in tool_types:
-            if tool_type._name() == tool_call.function.name:
-                current_tool_type = tool_type
-                break
-        if current_tool_type is None:
-            raise RuntimeError(
-                f"Unknown tool type in stream: {tool_call.function.name}"
-            )  # pragma: no cover
-        if previous_tool_call.id and previous_tool_type is not None:
-            return (
-                previous_tool_type.from_tool_call(previous_tool_call),
-                current_tool_call,
-                current_tool_type,
-            )
-
-    # Update arguments with each chunk
-    if tool_call.function and tool_call.function.arguments:
-        current_tool_call.function.arguments += cast(str, tool_call.function.arguments)  # pyright: ignore [reportOperatorIssue]
-
-    return None, current_tool_call, current_tool_type
-
-
-def handle_stream(
-    stream: Generator[CompletionEvent, None, None],
-    tool_types: list[type[MistralTool]] | None,
-    partial_tools: bool = False,
-) -> Generator[tuple[MistralCallResponseChunk, MistralTool | None], None, None]:
-    """Iterator over the stream and constructs tools as they are streamed."""
-    current_tool_call = ToolCall(
-        id="", function=FunctionCall(arguments="", name=""), type="function"
-    )
-    current_tool_type = None
-    last_chuk_data = None
-    for chunk in stream:
-        if not tool_types or not chunk.data.choices[0].delta.tool_calls:
-            if current_tool_type:
-                yield (
-                    MistralCallResponseChunk(chunk=chunk.data),
-                    current_tool_type.from_tool_call(current_tool_call),
-                )
-                current_tool_type = None
-            else:
-                yield MistralCallResponseChunk(chunk=chunk.data), None
-        tool, current_tool_call, current_tool_type = _handle_chunk(
-            chunk,
-            current_tool_call,
-            current_tool_type,
-            tool_types,
-        )
-        if tool is not None:
-            yield MistralCallResponseChunk(chunk=chunk.data), tool
-        else:
-            last_chuk_data = chunk.data
-    if current_tool_type and last_chuk_data:
-        yield (
-            MistralCallResponseChunk(chunk=last_chuk_data),
-            current_tool_type.from_tool_call(current_tool_call),
-        )
-
-
-async def handle_stream_async(
-    stream: AsyncGenerator[CompletionEvent, None],
-    tool_types: list[type[MistralTool]] | None,
-    partial_tools: bool = False,
-) -> AsyncGenerator[tuple[MistralCallResponseChunk, MistralTool | None], None]:
-    """Async iterator over the stream and constructs tools as they are streamed."""
-    current_tool_call = ToolCall(
-        id="", function=FunctionCall(arguments="", name=""), type="function"
-    )
-    current_tool_type = None
-    last_chuk_data = None
-    async for chunk in stream:
-        if not tool_types or not chunk.data.choices[0].delta.tool_calls:
-            if current_tool_type:
-                yield (
-                    MistralCallResponseChunk(chunk=chunk.data),
-                    current_tool_type.from_tool_call(current_tool_call),
-                )
-                current_tool_type = None
-            else:
-                yield MistralCallResponseChunk(chunk=chunk.data), None
-        tool, current_tool_call, current_tool_type = _handle_chunk(
-            chunk,
-            current_tool_call,
-            current_tool_type,
-            tool_types,
-        )
-        if tool is not None:
-            yield MistralCallResponseChunk(chunk=chunk.data), tool
-        else:
-            last_chuk_data = chunk.data
-    if current_tool_type and last_chuk_data:
-        yield (
-            MistralCallResponseChunk(chunk=last_chuk_data),
-            current_tool_type.from_tool_call(current_tool_call),
-        )

mirascope/core/mistral/_utils/_message_param_converter.py

@@ -1,176 +0,0 @@
-import base64
-import json
-import re
-from typing import cast
-
-from mistralai.models import (
-    AssistantMessage,
-    ImageURLChunk,
-    ReferenceChunk,
-    SystemMessage,
-    TextChunk,
-    ToolMessage,
-    UserMessage,
-)
-
-from mirascope.core.base._utils._base_message_param_converter import (
-    BaseMessageParamConverter,
-)
-from mirascope.core.mistral._utils import convert_message_params
-
-from ...base import BaseMessageParam, ImagePart, TextPart, ToolResultPart
-from ...base.message_param import ImageURLPart, ToolCallPart
-
-
-def _create_image_part_from_data_url(image_url: str) -> ImagePart | None:
-    match = re.match(r"data:(image/\w+);base64,(.+)", image_url)
-    if not match:
-        return None
-    mime_type = match.group(1)
-    image_base64 = match.group(2)
-    image_data = base64.b64decode(image_base64)
-    return ImagePart(
-        type="image",
-        media_type=mime_type,
-        image=image_data,
-        detail=None,
-    )
-
-
-class MistralMessageParamConverter(BaseMessageParamConverter):
-    """Converts between Mistral `AssistantMessage` and Mirascope `BaseMessageParam`."""
-
-    @staticmethod
-    def to_provider(message_params: list[BaseMessageParam]) -> list:
-        """
-        Convert from Mirascope `BaseMessageParam` to Mistral messages (AssistantMessage, etc.).
-        Mistral’s code snippet references convert_message_params returning a list of
-        [AssistantMessage|SystemMessage|ToolMessage|UserMessage].
-        """
-        return convert_message_params(
-            cast(
-                list[
-                    BaseMessageParam
-                    | AssistantMessage
-                    | SystemMessage
-                    | ToolMessage
-                    | UserMessage
-                ],
-                message_params,
-            )
-        )
-
-    @staticmethod
-    def from_provider(
-        message_params: list[
-            AssistantMessage | ToolMessage | SystemMessage | UserMessage
-        ],
-    ) -> list[BaseMessageParam]:
-        """
-        Convert from Mistral's `AssistantMessage` to Mirascope `BaseMessageParam`.
-        """
-        converted: list[BaseMessageParam] = []
-        for message_param in message_params:
-            content = message_param.content
-
-            converted_parts = []
-
-            if tool_calls := getattr(message_param, "tool_calls", None):
-                for tool in tool_calls:
-                    arguments = tool.function.arguments
-                    converted.append(
-                        BaseMessageParam(
-                            role="tool",
-                            content=[
-                                ToolCallPart(
-                                    type="tool_call",
-                                    name=tool.function.name,
-                                    id=tool.id,
-                                    args=json.loads(arguments)
-                                    if isinstance(arguments, str)
-                                    else arguments,
-                                )
-                            ],
-                        )
-                    )
-            elif isinstance(message_param, ToolMessage):
-                converted.append(
-                    BaseMessageParam(
-                        role="tool",
-                        content=[
-                            ToolResultPart(
-                                type="tool_result",
-                                name=message_param.name,  # pyright: ignore [reportArgumentType]
-                                content=message_param.content,  # pyright: ignore [reportArgumentType]
-                                id=message_param.tool_call_id,  # pyright: ignore [reportArgumentType]
-                            )
-                        ],
-                    )
-                )
-            elif isinstance(content, str):
-                converted_parts.append(TextPart(type="text", text=content))
-            elif isinstance(content, list):
-                for chunk in content:
-                    if isinstance(chunk, TextChunk):
-                        converted_parts.append(TextPart(type="text", text=chunk.text))
-
-                    elif isinstance(chunk, ImageURLChunk):
-                        image_url = chunk.image_url
-                        if isinstance(image_url, str):
-                            if image_part := _create_image_part_from_data_url(
-                                image_url
-                            ):
-                                converted_parts.append(image_part)
-                            else:
-                                converted_parts.append(
-                                    ImageURLPart(
-                                        type="image_url",
-                                        url=image_url,
-                                        detail=None,
-                                    )
-                                )
-
-                        else:
-                            img_url_str = image_url.url  # type: ignore
-                            if image_part := _create_image_part_from_data_url(
-                                img_url_str
-                            ):
-                                converted_parts.append(image_part)
-                            else:
-                                converted_parts.append(
-                                    ImageURLPart(
-                                        type="image_url",
-                                        url=img_url_str,
-                                        detail=image_url.detail
-                                        if isinstance(image_url.detail, str)
-                                        else None,
-                                    )
-                                )
-                    elif isinstance(chunk, ReferenceChunk):
-                        raise ValueError(
-                            "ReferenceChunk is not supported for conversion to BaseMessageParam."
-                        )
-
-                    else:
-                        # Unknown chunk type
-                        raise ValueError(
-                            f"Unsupported ContentChunk type: {type(chunk).__name__}"
-                        )
-
-            if len(converted_parts) == 1 and isinstance(converted_parts[0], TextPart):
-                converted.append(
-                    BaseMessageParam(
-                        role=message_param.role,  # pyright: ignore [reportArgumentType]
-                        content=converted_parts[0].text,
-                    )
-                )
-            else:
-                if converted_parts:
-                    converted.append(
-                        BaseMessageParam(
-                            role=message_param.role,  # pyright: ignore [reportArgumentType]
-                            content=converted_parts,
-                        )
-                    )
-
-        return converted

mirascope/core/mistral/_utils/_setup_call.py

@@ -1,164 +0,0 @@
-"""This module contains the setup_call function for Mistral tools."""
-
-import os
-from collections.abc import (
-    Awaitable,
-    Callable,
-)
-from typing import Any, cast, overload
-
-from mistralai import Mistral
-from mistralai.models import (
-    AssistantMessage,
-    ChatCompletionResponse,
-    CompletionEvent,
-    ResponseFormat,
-    SystemMessage,
-    TextChunk,
-    ToolChoiceEnum,
-    ToolMessage,
-    UserMessage,
-)
-from pydantic import BaseModel
-
-from ... import BaseMessageParam
-from ...base import BaseTool, _utils
-from ...base._utils import (
-    AsyncCreateFn,
-    CreateFn,
-    fn_is_async,
-    get_async_create_fn,
-    get_create_fn,
-)
-from ...base.call_params import CommonCallParams
-from ...base.stream_config import StreamConfig
-from .._call_kwargs import MistralCallKwargs
-from ..call_params import MistralCallParams
-from ..dynamic_config import MistralDynamicConfig
-from ..tool import MistralTool
-from ._convert_common_call_params import convert_common_call_params
-from ._convert_message_params import convert_message_params
-
-global_client: Mistral | None = None
-
-
-def _get_default_client() -> Mistral:
-    """Get or create the default Mistral client."""
-    global global_client
-    if global_client is None:
-        global_client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
-    return global_client
-
-
-@overload
-def setup_call(
-    *,
-    model: str,
-    client: Mistral | None,
-    fn: Callable[..., Awaitable[MistralDynamicConfig]],
-    fn_args: dict[str, Any],
-    dynamic_config: MistralDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: MistralCallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    AsyncCreateFn[ChatCompletionResponse, CompletionEvent],
-    str | None,
-    list[AssistantMessage | SystemMessage | ToolMessage | UserMessage],
-    list[type[MistralTool]] | None,
-    MistralCallKwargs,
-]: ...
-
-
-@overload
-def setup_call(
-    *,
-    model: str,
-    client: Mistral | None,
-    fn: Callable[..., MistralDynamicConfig],
-    fn_args: dict[str, Any],
-    dynamic_config: MistralDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: MistralCallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    CreateFn[ChatCompletionResponse, CompletionEvent],
-    str | None,
-    list[AssistantMessage | SystemMessage | ToolMessage | UserMessage],
-    list[type[MistralTool]] | None,
-    MistralCallKwargs,
-]: ...
-
-
-def setup_call(
-    *,
-    model: str,
-    client: Mistral | None,
-    fn: Callable[..., MistralDynamicConfig | Awaitable[MistralDynamicConfig]],
-    fn_args: dict[str, Any],
-    dynamic_config: MistralDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: MistralCallParams | CommonCallParams,
-    response_model: type[BaseModel] | None,
-    stream: bool | StreamConfig,
-) -> tuple[
-    CreateFn[ChatCompletionResponse, CompletionEvent]
-    | AsyncCreateFn[ChatCompletionResponse, CompletionEvent],
-    str | None,
-    list[AssistantMessage | SystemMessage | ToolMessage | UserMessage],
-    list[type[MistralTool]] | None,
-    MistralCallKwargs,
-]:
-    prompt_template, messages, tool_types, base_call_kwargs = _utils.setup_call(
-        fn,
-        fn_args,
-        dynamic_config,
-        tools,
-        MistralTool,
-        call_params,
-        convert_common_call_params,
-    )
-    call_kwargs = cast(MistralCallKwargs, base_call_kwargs)
-    messages = cast(
-        list[
-            BaseMessageParam
-            | AssistantMessage
-            | SystemMessage
-            | ToolMessage
-            | UserMessage
-        ],
-        messages,
-    )
-    messages = convert_message_params(messages)
-    if json_mode:
-        if not tools:
-            call_kwargs["response_format"] = ResponseFormat(type="json_object")
-        json_mode_content = _utils.json_mode_content(
-            tool_types[0] if tool_types else None
-        )
-        if messages[-1].role == "user":
-            if isinstance(messages[-1].content, list):
-                messages[-1].content.append(TextChunk(text=json_mode_content))
-            elif isinstance(messages[-1].content, str):
-                messages[-1].content += json_mode_content
-        else:
-            messages.append(UserMessage(content=json_mode_content.strip()))
-    elif response_model:
-        assert tool_types, "At least one tool must be provided for extraction."
-        call_kwargs["tool_choice"] = cast(ToolChoiceEnum, "any")
-    call_kwargs |= {"model": model, "messages": messages}
-
-    if client is None:
-        client = _get_default_client()
-    if fn_is_async(fn):
-        create_or_stream = get_async_create_fn(
-            client.chat.complete_async, client.chat.stream_async
-        )
-    else:
-        create_or_stream = get_create_fn(client.chat.complete, client.chat.stream)
-    return create_or_stream, prompt_template, messages, tool_types, call_kwargs

mirascope/core/mistral/call_params.py

@@ -1,36 +0,0 @@
-"""usage docs: learn/calls.md#provider-specific-parameters"""
-
-from __future__ import annotations
-
-from mistralai.models import ResponseFormat, ToolChoice, ToolChoiceEnum
-from typing_extensions import NotRequired
-
-from ..base import BaseCallParams
-
-
-class MistralCallParams(BaseCallParams):
-    """The parameters to use when calling the Mistral API.
-
-    [Mistral API Reference](https://docs.mistral.ai/api/)
-
-    Attributes:
-        endpoint: ...
-        max_tokens: ...
-        random_seed: ...
-        response_format: ...
-        safe_mode: ...
-        safe_prompt: ...
-        temperature: ...
-        tool_choice: ...
-        top_p: ...
-    """
-
-    endpoint: NotRequired[str | None]
-    max_tokens: NotRequired[int | None]
-    random_seed: NotRequired[int | None]
-    response_format: NotRequired[ResponseFormat | None]
-    safe_mode: NotRequired[bool | None]
-    safe_prompt: NotRequired[bool | None]
-    temperature: NotRequired[float | None]
-    tool_choice: NotRequired[ToolChoice | ToolChoiceEnum | None]
-    top_p: NotRequired[float | None]