mirascope 1.22.4__py3-none-any.whl → 2.1.1__py3-none-any.whl

mirascope/llm/call_response_chunk.py

@@ -1,66 +0,0 @@
-"""Call response chunk module."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from ..core.base.call_response_chunk import BaseCallResponseChunk
-from ..core.base.types import CostMetadata, FinishReason, Usage
-from ._response_metaclass import _ResponseMetaclass
-
-
-class CallResponseChunk(
-    BaseCallResponseChunk[Any, FinishReason],
-    metaclass=_ResponseMetaclass,
-):
-    _response: BaseCallResponseChunk[Any, Any]
-
-    def __init__(
-        self,
-        response: BaseCallResponseChunk[Any, Any],
-    ) -> None:
-        super().__init__(
-            **{field: getattr(response, field) for field in response.model_fields}
-        )
-        object.__setattr__(self, "_response", response)
-
-    def __getattribute__(self, name: str) -> Any:  # noqa: ANN401
-        special_names = {
-            "_response",
-            "__dict__",
-            "__class__",
-            "model_fields",
-            "__annotations__",
-            "__pydantic_validator__",
-            "__pydantic_fields_set__",
-            "__pydantic_extra__",
-            "__pydantic_private__",
-            "__class_getitem__",
-            "_properties",
-            "cost_metadata",
-            "finish_reasons",
-            "usage",
-        } | set(object.__getattribute__(self, "_properties"))
-
-        if name in special_names:
-            return object.__getattribute__(self, name)
-
-        try:
-            response = object.__getattribute__(self, "_response")
-            return getattr(response, name)
-        except AttributeError:
-            return object.__getattribute__(self, name)
-
-    @property
-    def finish_reasons(self) -> list[FinishReason] | None:
-        return self._response.common_finish_reasons
-
-    @property
-    def usage(self) -> Usage | None:
-        return self._response.common_usage
-
-    @property
-    def cost_metadata(self) -> CostMetadata:
-        """Get metadata required for cost calculation."""
-
-        return self._response.cost_metadata

mirascope/llm/stream.py

@@ -1,162 +0,0 @@
-"""This module contains the Stream class that inherits from BaseStream."""
-
-from __future__ import annotations
-
-from collections.abc import AsyncGenerator, Generator
-from typing import Any, TypeVar
-
-from ..core.base import (
-    BaseCallParams,
-    BaseCallResponse,
-    BaseCallResponseChunk,
-    BaseDynamicConfig,
-    BaseMessageParam,
-    BaseTool,
-)
-from ..core.base.call_response import JsonableType
-from ..core.base.stream import BaseStream
-from ..core.base.types import FinishReason
-from ..llm.call_response import CallResponse
-from ..llm.call_response_chunk import CallResponseChunk
-from .tool import Tool
-
-_BaseCallResponseT = TypeVar("_BaseCallResponseT", bound=BaseCallResponse)
-_BaseCallResponseChunkT = TypeVar(
-    "_BaseCallResponseChunkT", bound=BaseCallResponseChunk
-)
-_UserMessageParamT = TypeVar("_UserMessageParamT", bound=BaseMessageParam)
-_AssistantMessageParamT = TypeVar("_AssistantMessageParamT", bound=BaseMessageParam)
-_ToolMessageParamT = TypeVar("_ToolMessageParamT", bound=BaseMessageParam)
-_MessageParamT = TypeVar("_MessageParamT", bound=BaseMessageParam)
-_BaseToolT = TypeVar("_BaseToolT", bound=BaseTool)
-_ToolSchemaT = TypeVar("_ToolSchemaT")
-_BaseDynamicConfigT = TypeVar("_BaseDynamicConfigT", bound=BaseDynamicConfig)
-_BaseCallParamsT = TypeVar("_BaseCallParamsT", bound=BaseCallParams)
-_FinishReasonT = TypeVar("_FinishReasonT")
-
-
-class Stream(
-    BaseStream[
-        BaseCallResponse,
-        BaseCallResponseChunk,
-        BaseMessageParam,
-        BaseMessageParam,
-        BaseMessageParam,
-        BaseMessageParam,
-        BaseTool,
-        Any,
-        BaseDynamicConfig,
-        BaseCallParams,
-        FinishReason,
-    ],
-):
-    """A non-pydantic class that inherits from BaseStream."""
-
-    _stream: BaseStream[
-        BaseCallResponse,
-        BaseCallResponseChunk,
-        BaseMessageParam,
-        BaseMessageParam,
-        BaseMessageParam,
-        BaseMessageParam,
-        BaseTool,
-        Any,
-        BaseDynamicConfig,
-        BaseCallParams,
-        FinishReason,
-    ]
-
-    def __init__(
-        self,
-        *,
-        stream: BaseStream[
-            BaseCallResponse,
-            BaseCallResponseChunk,
-            BaseMessageParam,
-            BaseMessageParam,
-            BaseMessageParam,
-            BaseMessageParam,
-            BaseTool,
-            Any,
-            BaseDynamicConfig,
-            BaseCallParams,
-            FinishReason,
-        ],
-    ) -> None:
-        """Initialize the Stream class."""
-        object.__setattr__(self, "_stream", stream)
-
-    def __getattribute__(self, name: str) -> Any:  # noqa: ANN401
-        special_names = {
-            "_stream",
-            "cost",
-            "_construct_message_param",
-            "construct_call_response",
-            "tool_message_params",
-            "__dict__",
-            "__class__",
-            "__repr__",
-            "__str__",
-            "__iter__",
-            "__aiter__",
-        }
-
-        if name in special_names:
-            return object.__getattribute__(self, name)
-        response = object.__getattribute__(self, "_stream")
-        return getattr(response, name)
-
-    def __iter__(  # pyright: ignore [reportIncompatibleMethodOverride]
-        self,
-    ) -> Generator[
-        tuple[CallResponseChunk, Tool[_ToolMessageParamT] | None],
-        None,
-        None,
-    ]:
-        """Iterate over the stream."""
-        for chunk, tool in self._stream:
-            yield (
-                CallResponseChunk(response=chunk),  # pyright: ignore [reportAbstractUsage]
-                Tool(tool=tool) if tool is not None else None,  # pyright: ignore [reportAbstractUsage]
-            )
-
-    async def __aiter__(  # pyright: ignore [reportIncompatibleMethodOverride]
-        self,
-    ) -> AsyncGenerator[
-        tuple[CallResponseChunk, Tool[_ToolMessageParamT] | None],
-        None,
-    ]:
-        """Iterates over the stream and stores useful information."""
-        async for chunk, tool in self._stream:
-            yield (
-                CallResponseChunk(response=chunk),  # pyright: ignore [reportAbstractUsage]
-                Tool(tool=tool) if tool is not None else None,  # pyright: ignore [reportAbstractUsage]
-            )
-
-    @property
-    def cost(self) -> float | None:
-        return self._stream.cost
-
-    def _construct_message_param(
-        self, tool_calls: list[Any] | None = None, content: str | None = None
-    ) -> BaseMessageParam:
-        return self._stream._construct_message_param(
-            tool_calls=tool_calls, content=content
-        )
-
-    def construct_call_response(  # pyright: ignore [reportIncompatibleMethodOverride]
-        self,
-    ) -> CallResponse:
-        return CallResponse(response=self._stream.construct_call_response())  # pyright: ignore [reportAbstractUsage]
-
-    @classmethod
-    def tool_message_params(  # pyright: ignore [reportIncompatibleMethodOverride]
-        cls, tools_and_outputs: list[tuple[Tool, JsonableType]]
-    ) -> list[BaseMessageParam]:
-        """Returns the tool message parameters for tool call results.
-
-        Args:
-            tools_and_outputs: The list of tools and their outputs from which the tool
-                message parameters should be constructed.
-        """
-        return CallResponse.tool_message_params(tools_and_outputs)

mirascope/llm/tool.py

@@ -1,64 +0,0 @@
-"""Tool class for the provider-agnostic tool."""
-
-from __future__ import annotations
-
-from typing import Any, TypeVar
-
-from pydantic._internal._model_construction import ModelMetaclass
-
-from ..core.base.tool import BaseTool
-
-_ToolResponseT = TypeVar("_ToolResponseT", bound=BaseTool)
-
-
-class _DelegateAbstractMethodsForTool(ModelMetaclass):
-    def __new__(
-        mcls,
-        name: str,
-        bases: tuple[type, ...],
-        namespace: dict[str, Any],
-        **kwargs: Any,  # noqa: ANN401
-    ) -> type:
-        cls = super().__new__(mcls, name, bases, namespace)
-        cls.__abstractmethods__ = frozenset()
-        return cls
-
-
-_ToolMessageParamT = TypeVar("_ToolMessageParamT")
-
-
-class Tool(BaseTool, metaclass=_DelegateAbstractMethodsForTool):
-    """
-    A provider-agnostic Tool class.
-    - No BaseProviderConverter
-    - Relies on _response having `common_` methods/properties if needed.
-    """
-
-    _tool: BaseTool
-
-    def __init__(self, tool: BaseTool) -> None:
-        super().__init__(**{field: getattr(tool, field) for field in tool.model_fields})
-        object.__setattr__(self, "_tool", tool)
-
-    def __getattribute__(self, name: str) -> Any:  # noqa: ANN401
-        special_names = {
-            "_response",
-            "__dict__",
-            "__class__",
-            "model_fields",
-            "__annotations__",
-            "__pydantic_validator__",
-            "__pydantic_fields_set__",
-            "__pydantic_extra__",
-            "__pydantic_private__",
-            "__class_getitem__",
-        }
-
-        if name in special_names:
-            return object.__getattribute__(self, name)
-
-        try:
-            tool = object.__getattribute__(self, "_tool")
-            return getattr(tool, name)
-        except AttributeError:
-            return object.__getattribute__(self, name)

mirascope/mcp/__init__.py

@@ -1,7 +0,0 @@
-"""Mirascope Model Context Protocol (MCP) implementation."""
-
-from .client import MCPClient, sse_client, stdio_client
-from .server import MCPServer  # DEPRECATED
-from .tools import MCPTool  # DEPRECATED
-
-__all__ = ["MCPClient", "MCPServer", "MCPTool", "sse_client", "stdio_client"]

mirascope/mcp/_utils.py

@@ -1,277 +0,0 @@
-"""MCP client utility functions."""
-
-import base64
-import string
-from collections.abc import AsyncGenerator, Awaitable, Callable
-from contextlib import asynccontextmanager
-from typing import Any
-
-from anyio import create_memory_object_stream, create_task_group
-from anyio.streams.memory import MemoryObjectReceiveStream
-from mcp.types import (
-    EmbeddedResource,
-    ImageContent,
-    JSONRPCMessage,
-    PromptMessage,
-    TextContent,
-    TextResourceContents,
-)
-from mcp.types import Tool as MCPTool
-from pydantic import BaseModel, ConfigDict, Field, create_model
-
-from ..core import BaseMessageParam, BaseTool
-from ..core.base import AudioPart, DocumentPart, ImagePart
-
-
-def create_tool_call(
-    name: str,
-    call_tool: Callable[[str, dict | None], Awaitable[Any]],
-) -> Callable[..., Awaitable[list[str | ImageContent | EmbeddedResource]]]:
-    """Create a tool call function for a Mirascope Tool.
-
-    Args:
-        name: The name of the tool
-        call_tool: The function to call the tool
-
-    Returns:
-        A function that can be used as the call method for a Tool
-    """
-
-    async def call(self: BaseTool) -> list[str | ImageContent | EmbeddedResource]:
-        result = await call_tool(name, self.args)  # pyright: ignore [reportOptionalCall]
-        if result.isError:
-            raise RuntimeError(f"MCP Server returned error: {self._name()}")
-        return [
-            content.text if isinstance(content, TextContent) else content
-            for content in result.content
-        ]
-
-    return call
-
-
-def convert_prompt_message_to_base_message_params(
-    prompt_message: PromptMessage,
-) -> BaseMessageParam:
-    """
-    Convert a single PromptMessage back into a BaseMessageParam.
-
-    Args:
-        prompt_message: A PromptMessage instance.
-
-    Returns:
-        A BaseMessageParam instance representing the given prompt_message.
-
-    Raises:
-        ValueError: If the role is invalid or if the content type is unsupported.
-    """
-
-    # Validate role
-    if prompt_message.role not in ["user", "assistant"]:
-        raise ValueError(f"invalid role: {prompt_message.role}")
-
-    content = prompt_message.content
-
-    # Handle TextContent
-    if isinstance(content, TextContent):
-        # If it's text, we can just return a single string
-        return BaseMessageParam(role=prompt_message.role, content=content.text)
-
-    # Handle ImageContent
-    elif isinstance(content, ImageContent):
-        decoded_image = base64.b64decode(content.data)
-
-        image_part = ImagePart(
-            type="image",
-            image=decoded_image,
-            media_type=content.mimeType,
-            detail=None,  # detail not provided by PromptMessage
-        )
-        return BaseMessageParam(role=prompt_message.role, content=[image_part])
-
-    elif isinstance(content, EmbeddedResource):
-        resource = content.resource
-        if isinstance(resource, TextResourceContents):
-            # For text content embedded resources, just return the text
-            return BaseMessageParam(role=prompt_message.role, content=resource.text)
-        else:
-            mime_type = resource.mimeType
-            if not mime_type:
-                raise ValueError(
-                    "BlobResourceContents has no mimeType, cannot determine content type."
-                )
-
-            decoded_data = base64.b64decode(resource.blob)
-
-            if mime_type.startswith("image/"):
-                # Treat as ImagePart
-                image_part = ImagePart(
-                    type="image",
-                    image=decoded_data,
-                    media_type=mime_type,
-                    detail=None,
-                )
-                return BaseMessageParam(role=prompt_message.role, content=[image_part])
-            elif mime_type == "application/pdf":
-                doc_part = DocumentPart(
-                    type="document", media_type=mime_type, document=decoded_data
-                )
-                return BaseMessageParam(role=prompt_message.role, content=[doc_part])
-            elif mime_type.startswith("audio/"):
-                # Treat as AudioPart
-                audio_part = AudioPart(
-                    type="audio", media_type=mime_type, audio=decoded_data
-                )
-                return BaseMessageParam(role=prompt_message.role, content=[audio_part])
-            else:
-                raise ValueError(f"Unsupported mime type: {mime_type}")
-
-    else:
-        raise ValueError(f"Unsupported content type: {type(content)}")
-
-
-def snake_to_pascal(snake: str) -> str:
-    """Convert a snake_case string to PascalCase.
-
-    Args:
-        snake: A snake_case string
-
-    Returns:
-        The string converted to PascalCase
-    """
-    return string.capwords(snake.replace("_", " ")).replace(" ", "")
-
-
-def build_object_type(
-    properties: dict[str, Any], required: list[str], name: str
-) -> type[BaseModel]:
-    """Build a Pydantic model from JSON Schema properties.
-
-    Args:
-        properties: JSON Schema properties dictionary
-        required: List of required property names
-        name: Name for the generated model
-
-    Returns:
-        A dynamically created Pydantic model class
-    """
-    fields = {}
-    for prop_name, prop_schema in properties.items():
-        class_name = snake_to_pascal(prop_name)
-        type_ = json_schema_to_python_type(prop_schema, class_name)
-        if prop_name in required:
-            fields[prop_name] = (
-                type_,
-                Field(..., description=prop_schema.get("description")),
-            )
-        else:
-            fields[prop_name] = (
-                type_ | None,
-                Field(None, description=prop_schema.get("description")),
-            )
-
-    return create_model(name, __config__=ConfigDict(extra="allow"), **fields)
-
-
-def json_schema_to_python_type(schema: dict[str, Any], name: str = "Model") -> Any:  # noqa: ANN401
-    """
-    Recursively convert a JSON Schema snippet into a Python type annotation or a dynamically generated pydantic model.
-
-    Args:
-        schema: JSON Schema to convert
-        name: Name for any generated models
-
-    Returns:
-        Corresponding Python type or Pydantic model
-    """
-    json_type = schema.get("type", "any")
-
-    if json_type == "string":
-        return str
-    elif json_type == "number":
-        return float
-    elif json_type == "integer":
-        return int
-    elif json_type == "boolean":
-        return bool
-    elif json_type == "array":
-        # Recursively determine the items type for arrays
-        items_schema = schema.get("items", {})
-        items_type = json_schema_to_python_type(items_schema)
-        return list[items_type]
-    elif json_type == "object":
-        # Recursively build a dynamic model for objects
-        properties = schema.get("properties", {})
-        required = schema.get("required", [])
-        return build_object_type(properties, required, name)
-    else:
-        # Default fallback
-        return Any
-
-
-def create_tool_from_mcp_tool(tool: MCPTool) -> type[BaseTool]:
-    """
-    Create a `BaseTool` type definition from the given MCP Tool instance.
-
-    Args:
-        tool: MCP tool instance.
-
-    Returns:
-        A dynamically created `Tool` schema.
-    """
-    schema = tool.inputSchema
-    properties = schema.get("properties", {})
-    required_fields = schema.get("required", [])
-
-    fields = {}
-    for field_name, field_schema in properties.items():
-        field_type = json_schema_to_python_type(field_schema)
-
-        if field_name in required_fields:
-            default = Field(..., description=field_schema.get("description"))
-            annotation = field_type
-        else:
-            default = Field(None, description=field_schema.get("description"))
-            annotation = field_type | None
-
-        fields[field_name] = (annotation, default)
-
-    return create_model(snake_to_pascal(tool.name), __base__=BaseTool, **fields)
-
-
-@asynccontextmanager
-async def read_stream_exception_filer(
-    original_read: MemoryObjectReceiveStream[JSONRPCMessage | Exception],
-    exception_handler: Callable[[Exception], None] | None = None,
-) -> AsyncGenerator[MemoryObjectReceiveStream[JSONRPCMessage], None]:
-    """
-    Handle exceptions in the original stream.
-    Default handler is to ignore read stream exception for invalid JSON lines and log them.
-
-    Args:
-        original_read: The original stream to read from.
-        exception_handler: An optional handler for exception.
-
-    Yields:
-        A filtered stream with exceptions removed
-    """
-    read_stream_writer, filtered_read = create_memory_object_stream(0)
-
-    async def task() -> None:
-        try:
-            async with original_read:
-                async for msg in original_read:
-                    if isinstance(msg, Exception):
-                        if exception_handler:
-                            exception_handler(msg)
-                        continue
-                    await read_stream_writer.send(msg)
-        finally:
-            await read_stream_writer.aclose()
-
-    async with create_task_group() as tg:
-        tg.start_soon(task)
-        try:
-            yield filtered_read
-        finally:
-            await filtered_read.aclose()
-            tg.cancel_scope.cancel()