mirascope 1.16.8__tar.gz → 1.16.9__tar.gz

{mirascope-1.16.8 → mirascope-1.16.9}/.pre-commit-config.yaml

@@ -15,7 +15,7 @@ repos:
       - id: ruff-format
         files: "^mirascope|^tests|^examples|^docs"
   - repo: https://github.com/RobertCraigie/pyright-python
-    rev: v1.1.391
+    rev: v1.1.393
     hooks:
       - id: pyright
   - repo: local

{mirascope-1.16.8 → mirascope-1.16.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mirascope
-Version: 1.16.8
+Version: 1.16.9
 Summary: LLM abstractions that aren't obstructions
 Project-URL: Homepage, https://mirascope.com
 Project-URL: Documentation, https://mirascope.com/WELCOME

{mirascope-1.16.8 → mirascope-1.16.9}/mirascope/core/anthropic/call_response.py

@@ -186,5 +186,13 @@ class AnthropicCallResponse(
         return _convert_finish_reasons_to_common_finish_reasons(self.finish_reasons)
 
     @property
-    def common_message_param(self) -> list[BaseMessageParam]:
-        return AnthropicMessageParamConverter.from_provider([(self.message_param)])
+    def common_message_param(self) -> BaseMessageParam:
+        return AnthropicMessageParamConverter.from_provider([(self.message_param)])[0]
+
+    @property
+    def common_user_message_param(self) -> BaseMessageParam | None:
+        if not self.user_message_param:
+            return None
+        return AnthropicMessageParamConverter.from_provider(
+            [(self.user_message_param)]
+        )[0]

mirascope-1.16.9/mirascope/core/azure/_utils/_message_param_converter.py

@@ -0,0 +1,83 @@
+import json
+from typing import cast
+
+from azure.ai.inference.models import (
+    AssistantMessage,
+    ChatRequestMessage,
+    TextContentItem,
+    ToolMessage,
+    UserMessage,
+)
+
+from mirascope.core.azure._utils import convert_message_params
+from mirascope.core.base import BaseMessageParam, TextPart, ToolCallPart, ToolResultPart
+from mirascope.core.base._utils._base_message_param_converter import (
+    BaseMessageParamConverter,
+)
+
+
+class AzureMessageParamConverter(BaseMessageParamConverter):
+    """Converts between Azure `ChatRequestMessage` / `AssistantMessage` and Mirascope `BaseMessageParam`."""
+
+    @staticmethod
+    def to_provider(message_params: list[BaseMessageParam]) -> list[ChatRequestMessage]:
+        """Convert from Mirascope `BaseMessageParam` to Azure's `ChatRequestMessage`."""
+        return convert_message_params(
+            cast(list[BaseMessageParam | ChatRequestMessage], message_params)
+        )
+
+    @staticmethod
+    def from_provider(
+        message_params: list[ChatRequestMessage],
+    ) -> list[BaseMessageParam]:
+        """
+        Convert from Azure's `AssistantMessage` back to Mirascope `BaseMessageParam`.
+        """
+        converted: list[BaseMessageParam] = []
+        for message_param in message_params:
+            if isinstance(message_param, UserMessage):
+                if isinstance(message_param.content, str):
+                    converted.append(
+                        BaseMessageParam(role="user", content=message_param.content)
+                    )
+                elif isinstance(message_param.content, list):
+                    converted_parts = []
+                    for part in message_param.content:
+                        if isinstance(part, TextContentItem):
+                            converted_parts.append(
+                                TextPart(type="text", text=part.text)
+                            )
+                        # TODO: add support for image and audio parts here
+                    converted.append(
+                        BaseMessageParam(role="user", content=converted_parts)
+                    )
+            elif isinstance(message_param, AssistantMessage):
+                if tool_calls := message_param.tool_calls:
+                    content = [
+                        ToolCallPart(
+                            type="tool_call",
+                            name=tool_call.function.name,
+                            id=tool_call.id,
+                            args=json.loads(tool_call.function.arguments),
+                        )
+                        for tool_call in tool_calls
+                    ]
+                else:
+                    content = message_param.content or ""
+                converted.append(BaseMessageParam(role="assistant", content=content))
+            elif isinstance(message_param, ToolMessage):
+                converted.append(
+                    BaseMessageParam(
+                        role="tool",
+                        content=[
+                            ToolResultPart(
+                                type="tool_result",
+                                name="",
+                                content=message_param.content,
+                                id=message_param.tool_call_id,
+                                is_error=False,
+                            )
+                        ],
+                    )
+                )
+        return converted

{mirascope-1.16.8 → mirascope-1.16.9}/mirascope/core/azure/call_response.py

@@ -199,5 +199,11 @@ class AzureCallResponse(
         )
 
     @property
-    def common_message_param(self) -> list[BaseMessageParam]:
-        return AzureMessageParamConverter.from_provider([self.message_param])
+    def common_message_param(self) -> BaseMessageParam:
+        return AzureMessageParamConverter.from_provider([self.message_param])[0]
+
+    @property
+    def common_user_message_param(self) -> BaseMessageParam | None:
+        if not self.user_message_param:
+            return None
+        return AzureMessageParamConverter.from_provider([self.user_message_param])[0]

{mirascope-1.16.8 → mirascope-1.16.9}/mirascope/core/base/_create.py

@@ -166,7 +166,7 @@ def create_factory(  # noqa: ANN202
             @wraps(fn)
             async def inner_async(
                 *args: _P.args, **kwargs: _P.kwargs
-            ) -> TCallResponse | _ParsedOutputT:
+            ) -> TCallResponse | _ParsedOutputT:  # pyright: ignore [reportInvalidTypeForm]
                 fn_args = get_fn_args(fn, args, kwargs)
                 dynamic_config = await get_dynamic_configuration(fn, args, kwargs)
                 nonlocal client

{mirascope-1.16.8 → mirascope-1.16.9}/mirascope/core/base/_utils/_convert_function_to_base_tool.py

@@ -114,7 +114,7 @@ def convert_function_to_base_tool(
     if examples:
         model.model_config["json_schema_extra"] = {"examples": examples}
 
-    def call(self: base) -> Any:  # noqa: ANN401
+    def call(self: base) -> Any:  # pyright: ignore [reportInvalidTypeForm] # noqa: ANN401
         return fn(
             **(
                 ({"self": self} if has_self else {})
@@ -129,7 +129,7 @@ def convert_function_to_base_tool(
             )
         )
 
-    async def call_async(self: base) -> Callable:
+    async def call_async(self: base) -> Callable:  # pyright: ignore [reportInvalidTypeForm]
         return await call(self)
 
     if inspect.iscoroutinefunction(fn):

{mirascope-1.16.8 → mirascope-1.16.9}/mirascope/core/base/call_response.py

@@ -275,10 +275,16 @@ class BaseCallResponse(
 
     @property
     @abstractmethod
-    def common_message_param(self) -> list[BaseMessageParam]:
+    def common_message_param(self) -> BaseMessageParam:
         """Provider-agnostic assistant message param."""
         ...
 
+    @property
+    @abstractmethod
+    def common_user_message_param(self) -> BaseMessageParam | None:
+        """Provider-agnostic user message param."""
+        ...
+
     @property
     def common_tools(self) -> list[Tool] | None:
         """Provider-agnostic tools."""

{mirascope-1.16.8 → mirascope-1.16.9}/mirascope/core/bedrock/call_response.py

@@ -232,5 +232,11 @@ class BedrockCallResponse(
         return _convert_finish_reasons_to_common_finish_reasons(self.finish_reasons)
 
     @property
-    def common_message_param(self) -> list[BaseMessageParam]:
-        return BedrockMessageParamConverter.from_provider([self.message_param])
+    def common_message_param(self) -> BaseMessageParam:
+        return BedrockMessageParamConverter.from_provider([self.message_param])[0]
+
+    @property
+    def common_user_message_param(self) -> BaseMessageParam | None:
+        if not self.user_message_param:
+            return None
+        return BedrockMessageParamConverter.from_provider([self.user_message_param])[0]  # pyright: ignore [reportArgumentType]

{mirascope-1.16.8 → mirascope-1.16.9}/mirascope/core/cohere/_utils/_message_param_converter.py

@@ -29,9 +29,10 @@ class CohereMessageParamConverter(BaseMessageParamConverter):
         """
         converted = []
         for message_param in message_params:
+            role = getattr(message_param, "role", "assistant")
             if not message_param.tool_calls:
                 converted.append(
-                    BaseMessageParam(role="assistant", content=message_param.message)
+                    BaseMessageParam(role=role, content=message_param.message)
                 )
                 continue
 
@@ -49,5 +50,5 @@ class CohereMessageParamConverter(BaseMessageParamConverter):
                     )
                 )
 
-            converted.append(BaseMessageParam(role="tool", content=converted_content))
+            converted.append(BaseMessageParam(role=role, content=converted_content))
         return converted

{mirascope-1.16.8 → mirascope-1.16.9}/mirascope/core/cohere/call_response.py

@@ -188,5 +188,11 @@ class CohereCallResponse(
         return _convert_finish_reasons_to_common_finish_reasons(self.finish_reasons)
 
     @property
-    def common_message_param(self) -> list[BaseMessageParam]:
-        return CohereMessageParamConverter.from_provider([self.message_param])
+    def common_message_param(self) -> BaseMessageParam:
+        return CohereMessageParamConverter.from_provider([self.message_param])[0]
+
+    @property
+    def common_user_message_param(self) -> BaseMessageParam | None:
+        if not self.user_message_param:
+            return None
+        return CohereMessageParamConverter.from_provider([self.user_message_param])[0]

{mirascope-1.16.8 → mirascope-1.16.9}/mirascope/core/gemini/_utils/_message_param_converter.py

@@ -57,7 +57,11 @@ class GeminiMessageParamConverter(BaseMessageParamConverter):
         """
         converted: list[BaseMessageParam] = []
         for message_param in message_params:
-            role: str = "assistant"
+            role: str = (
+                "assistant"
+                if message_param["role"] == "model"
+                else message_param["role"]
+            )
             content_list = []
             for part in cast(
                 list[protos.Part | protos.FunctionCall | protos.FunctionResponse],

{mirascope-1.16.8 → mirascope-1.16.9}/mirascope/core/gemini/call_response.py

@@ -199,5 +199,11 @@ class GeminiCallResponse(
         return _convert_finish_reasons_to_common_finish_reasons(self.finish_reasons)
 
     @property
-    def common_message_param(self) -> list[BaseMessageParam]:
-        return GeminiMessageParamConverter.from_provider([self.message_param])
+    def common_message_param(self) -> BaseMessageParam:
+        return GeminiMessageParamConverter.from_provider([self.message_param])[0]
+
+    @property
+    def common_user_message_param(self) -> BaseMessageParam | None:
+        if not self.user_message_param:
+            return None
+        return GeminiMessageParamConverter.from_provider([self.user_message_param])[0]

mirascope-1.16.9/mirascope/core/groq/_utils/_message_param_converter.py

@@ -0,0 +1,82 @@
+import json
+from typing import cast
+
+from groq.types.chat import ChatCompletionMessageParam
+
+from mirascope.core import BaseMessageParam
+from mirascope.core.base import TextPart, ToolResultPart
+from mirascope.core.base._utils._base_message_param_converter import (
+    BaseMessageParamConverter,
+)
+from mirascope.core.base.message_param import ToolCallPart
+from mirascope.core.groq._utils import convert_message_params
+
+
+class GroqMessageParamConverter(BaseMessageParamConverter):
+    """Converts between Groq `ChatCompletionMessageParam` and Mirascope `BaseMessageParam`."""
+
+    @staticmethod
+    def to_provider(
+        message_params: list[BaseMessageParam],
+    ) -> list[ChatCompletionMessageParam]:
+        """
+        Convert from Mirascope `BaseMessageParam` to Groq `ChatCompletionMessageParam`.
+        """
+        return convert_message_params(
+            cast(list[BaseMessageParam | ChatCompletionMessageParam], message_params)
+        )
+
+    @staticmethod
+    def from_provider(
+        message_params: list[ChatCompletionMessageParam],
+    ) -> list[BaseMessageParam]:
+        """Convert from Groq's `ChatCompletionAssistantMessageParam` to Mirascope `BaseMessageParam`."""
+        converted = []
+        for message_param in message_params:
+            contents = []
+            content = message_param.get("content")
+            if message_param["role"] == "tool":
+                converted.append(
+                    BaseMessageParam(
+                        role="tool",
+                        content=[
+                            ToolResultPart(
+                                type="tool_result",
+                                name=getattr(message_param, "name", ""),
+                                content=message_param["content"],
+                                id=message_param["tool_call_id"],
+                                is_error=False,
+                            )
+                        ],
+                    )
+                )
+                continue
+            if tool_calls := message_param.get("tool_calls"):
+                for tool_call in tool_calls:
+                    contents.append(
+                        ToolCallPart(
+                            type="tool_call",
+                            name=tool_call["function"]["name"],
+                            id=tool_call["id"],
+                            args=json.loads(tool_call["function"]["arguments"]),
+                        )
+                    )
+            elif isinstance(content, str):
+                converted.append(
+                    BaseMessageParam(role=message_param["role"], content=content)
+                )
+                continue
+            elif isinstance(content, list):
+                for part in content:
+                    if "text" in part:
+                        contents.append(TextPart(type="text", text=part["text"]))
+                    # TODO: add support for image parts here
+            if contents:
+                converted.append(
+                    BaseMessageParam(role=message_param["role"], content=contents)
+                )
+            else:
+                converted.append(
+                    BaseMessageParam(role=message_param["role"], content="")
+                )
+        return converted

{mirascope-1.16.8 → mirascope-1.16.9}/mirascope/core/groq/call_response.py

@@ -181,5 +181,11 @@ class GroqCallResponse(
         return cast(list[FinishReason], self.finish_reasons)
 
     @property
-    def common_message_param(self) -> list[BaseMessageParam]:
-        return GroqMessageParamConverter.from_provider([self.message_param])
+    def common_message_param(self) -> BaseMessageParam:
+        return GroqMessageParamConverter.from_provider([self.message_param])[0]
+
+    @property
+    def common_user_message_param(self) -> BaseMessageParam | None:
+        if not self.user_message_param:
+            return None
+        return GroqMessageParamConverter.from_provider([self.user_message_param])[0]

{mirascope-1.16.8 → mirascope-1.16.9}/mirascope/core/mistral/call_response.py

@@ -186,5 +186,11 @@ class MistralCallResponse(
         return _convert_finish_reasons_to_common_finish_reasons(self.finish_reasons)
 
     @property
-    def common_message_param(self) -> list[BaseMessageParam]:
-        return MistralMessageParamConverter.from_provider([self.message_param])
+    def common_message_param(self) -> BaseMessageParam:
+        return MistralMessageParamConverter.from_provider([self.message_param])[0]
+
+    @property
+    def common_user_message_param(self) -> BaseMessageParam | None:
+        if not self.user_message_param:
+            return None
+        return MistralMessageParamConverter.from_provider([self.user_message_param])[0]

{mirascope-1.16.8 → mirascope-1.16.9}/mirascope/core/openai/_utils/_convert_message_params.py

@@ -105,4 +105,5 @@ def convert_message_params(
                 converted_message_params.append(
                     {"role": message_param.role, "content": converted_content}
                 )
+    # print(converted_message_params)
     return converted_message_params

{mirascope-1.16.8 → mirascope-1.16.9}/mirascope/core/openai/_utils/_message_param_converter.py

@@ -3,10 +3,7 @@
 import json
 from typing import cast
 
-from openai.types.chat import (
-    ChatCompletionAssistantMessageParam,
-    ChatCompletionMessageParam,
-)
+from openai.types.chat import ChatCompletionMessageParam
 
 from mirascope.core import BaseMessageParam
 from mirascope.core.base import TextPart, ToolCallPart, ToolResultPart
@@ -28,14 +25,18 @@ class OpenAIMessageParamConverter(BaseMessageParamConverter):
 
     @staticmethod
     def from_provider(
-        message_params: list[ChatCompletionAssistantMessageParam],
+        message_params: list[ChatCompletionMessageParam],
     ) -> list[BaseMessageParam]:
         """Converts OpenAI message params to base message params."""
         converted = []
         for message_param in message_params:
             contents = []
             content = message_param.get("content")
-            if message_param["role"] == "tool":
+            if (
+                message_param["role"] == "tool"
+                and "name" in message_param
+                and "content" in message_param
+            ):
                 converted.append(
                     BaseMessageParam(
                         role="tool",
@@ -61,7 +62,8 @@ class OpenAIMessageParamConverter(BaseMessageParamConverter):
                     if "text" in part:
                         contents.append(TextPart(type="text", text=part["text"]))
                     else:
-                        raise ValueError(part["refusal"])
+                        # TODO: add support for image and audio parts here
+                        raise ValueError(part["refusal"])  # pyright: ignore [reportGeneralTypeIssues]
             if tool_calls := message_param.get("tool_calls"):
                 for tool_call in tool_calls:
                     contents.append(

{mirascope-1.16.8 → mirascope-1.16.9}/mirascope/core/openai/call_response.py

@@ -229,5 +229,11 @@ class OpenAICallResponse(
         return cast(list[FinishReason], self.finish_reasons)
 
     @property
-    def common_message_param(self) -> list[BaseMessageParam]:
-        return OpenAIMessageParamConverter.from_provider([self.message_param])
+    def common_message_param(self) -> BaseMessageParam:
+        return OpenAIMessageParamConverter.from_provider([self.message_param])[0]
+
+    @property
+    def common_user_message_param(self) -> BaseMessageParam | None:
+        if not self.user_message_param:
+            return None
+        return OpenAIMessageParamConverter.from_provider([self.user_message_param])[0]

{mirascope-1.16.8 → mirascope-1.16.9}/mirascope/core/vertex/_utils/_message_param_converter.py

@@ -52,14 +52,16 @@ class VertexMessageParamConverter(BaseMessageParamConverter):
         """
         converted = []
         for message_param in message_params:
-            role: str = "assistant"
+            role: str = (
+                "assistant" if message_param.role == "model" else message_param.role
+            )
             contents = []
             has_tool_call = False
             for part in message_param.parts:
                 if part.function_response:
                     converted.append(
                         BaseMessageParam(
-                            role=role,
+                            role=message_param.role,
                             content=[
                                 ToolResultPart(
                                     type="tool_result",

{mirascope-1.16.8 → mirascope-1.16.9}/mirascope/core/vertex/call_response.py

@@ -191,5 +191,11 @@ class VertexCallResponse(
         return _convert_finish_reasons_to_common_finish_reasons(self.finish_reasons)
 
     @property
-    def common_message_param(self) -> list[BaseMessageParam]:
-        return VertexMessageParamConverter.from_provider([self.message_param])
+    def common_message_param(self) -> BaseMessageParam:
+        return VertexMessageParamConverter.from_provider([self.message_param])[0]
+
+    @property
+    def common_user_message_param(self) -> BaseMessageParam | None:
+        if not self.user_message_param:
+            return None
+        return VertexMessageParamConverter.from_provider([self.user_message_param])[0]

{mirascope-1.16.8 → mirascope-1.16.9}/mirascope/llm/call_response.py

@@ -54,10 +54,14 @@ class CallResponse(
             **{field: getattr(response, field) for field in response.model_fields}
         )
         object.__setattr__(self, "_response", response)
+        object.__setattr__(
+            self, "user_message_param", response.common_user_message_param
+        )
 
     def __getattribute__(self, name: str) -> Any:  # noqa: ANN401
         special_names = {
             "_response",
+            "user_message_param",
             "__dict__",
             "__class__",
             "model_fields",
@@ -96,12 +100,12 @@ class CallResponse(
 
     @computed_field
     @cached_property
-    def tools(self) -> list[Tool] | None:  # pyright: ignore [reportIncompatibleMethodOverride]
+    def tools(self) -> list[Tool] | None:  # pyright: ignore [reportIncompatibleVariableOverride]
         return self._response.common_tools
 
     @computed_field
     @cached_property
-    def tool(self) -> Tool | None:
+    def tool(self) -> Tool | None:  # pyright: ignore [reportIncompatibleVariableOverride]
         tools = self._response.common_tools
         if tools:
             return tools[0]

{mirascope-1.16.8 → mirascope-1.16.9}/mirascope/llm/stream.py

@@ -100,7 +100,7 @@ class Stream(
             call_kwargs=stream.call_kwargs,
         )
 
-    def __iter__(
+    def __iter__(  # pyright: ignore [reportIncompatibleMethodOverride]
         self,
     ) -> Generator[
         tuple[
@@ -116,7 +116,7 @@ class Stream(
                 Tool(tool=tool) if tool is not None else None,  # pyright: ignore [reportAbstractUsage]
             )
 
-    async def __aiter__(
+    async def __aiter__(  # pyright: ignore [reportIncompatibleMethodOverride]
         self,
     ) -> AsyncGenerator[
         tuple[
@@ -150,7 +150,7 @@ class Stream(
             tool_calls=tool_calls, content=content
         )
 
-    def construct_call_response(
+    def construct_call_response(  # pyright: ignore [reportIncompatibleMethodOverride]
         self,
     ) -> CallResponse[_BaseCallResponseT, Tool[_ToolMessageParamT]]:
         return self.common_construct_call_response()

{mirascope-1.16.8 → mirascope-1.16.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mirascope"
-version = "1.16.8"
+version = "1.16.9"
 description = "LLM abstractions that aren't obstructions"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -89,7 +89,7 @@ mcp = ["mcp>=1.0.0"]
 dev-dependencies = [
     "ruff>=0.6.1",
     "pytest>=8.3.2",
-    "pyright>=1.1.391",
+    "pyright>=1.1.393",
     "pytest-asyncio>=0.23.8",
     "pytest-cov>=5.0.0",
     "pre-commit>=3.8.0",

{mirascope-1.16.8 → mirascope-1.16.9}/tests/core/anthropic/test_call_response.py

@@ -59,11 +59,14 @@ def test_anthropic_call_response() -> None:
     assert call_response.tools is None
     assert call_response.tool is None
     assert call_response.common_finish_reasons == ["stop"]
-    assert call_response.common_message_param == [
-        BaseMessageParam(
-            role="assistant", content=[TextPart(type="text", text="content")]
-        )
-    ]
+    assert call_response.common_message_param == BaseMessageParam(
+        role="assistant", content=[TextPart(type="text", text="content")]
+    )
+    assert call_response.common_user_message_param is None
+    call_response.user_message_param = {"role": "user", "content": "content"}
+    assert call_response.common_user_message_param == BaseMessageParam(
+        role="user", content="content"
+    )
 
 
 def test_anthropic_call_response_with_tools() -> None: