mirascope 2.0.0__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

mirascope/llm/providers/mlx/provider.py

@@ -1,452 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Sequence
-from functools import cache, lru_cache
-from typing import TYPE_CHECKING, cast
-from typing_extensions import Unpack
-
-import mlx.nn as nn
-from mlx_lm import load as mlx_load
-from transformers import PreTrainedTokenizer
-
-from ...context import Context, DepsT
-from ...formatting import Format, FormattableT, OutputParser
-from ...messages import Message
-from ...responses import (
-    AsyncContextResponse,
-    AsyncContextStreamResponse,
-    AsyncResponse,
-    AsyncStreamResponse,
-    ContextResponse,
-    ContextStreamResponse,
-    Response,
-    StreamResponse,
-)
-from ...tools import (
-    AsyncContextTool,
-    AsyncContextToolkit,
-    AsyncTool,
-    AsyncToolkit,
-    ContextTool,
-    ContextToolkit,
-    Tool,
-    Toolkit,
-)
-from ..base import BaseProvider
-from . import _utils
-from .encoding import TransformersEncoder
-from .mlx import MLX
-from .model_id import MLXModelId
-
-if TYPE_CHECKING:
-    from ...models import Params
-
-
-@cache
-def _mlx_client_singleton() -> MLXProvider:
-    """Get or create the singleton MLX client instance."""
-    return MLXProvider()
-
-
-def client() -> MLXProvider:
-    """Get the MLX client singleton instance."""
-    return _mlx_client_singleton()
-
-
-@lru_cache(maxsize=16)
-def _get_mlx(model_id: MLXModelId) -> MLX:
-    model, tokenizer = cast(tuple[nn.Module, PreTrainedTokenizer], mlx_load(model_id))
-    encoder = TransformersEncoder(tokenizer)
-    return MLX(
-        model_id,
-        model,
-        tokenizer,
-        encoder,
-    )
-
-
-class MLXProvider(BaseProvider[None]):
-    """Client for interacting with MLX language models.
-
-    This client provides methods for generating responses from MLX models,
-    supporting both synchronous and asynchronous operations, as well as
-    streaming responses.
-    """
-
-    id = "mlx"
-    default_scope = "mlx-community/"
-    error_map = _utils.MLX_ERROR_MAP
-
-    def get_error_status(self, e: Exception) -> int | None:
-        """Extract HTTP status code from MLX exception.
-
-        MLX/HuggingFace Hub exceptions don't have status codes.
-        """
-        return None
-
-    def _call(
-        self,
-        *,
-        model_id: MLXModelId,
-        messages: Sequence[Message],
-        tools: Sequence[Tool] | Toolkit | None = None,
-        format: type[FormattableT]
-        | Format[FormattableT]
-        | OutputParser[FormattableT]
-        | None = None,
-        **params: Unpack[Params],
-    ) -> Response | Response[FormattableT]:
-        """Generate an `llm.Response` using MLX model.
-
-        Args:
-            model_id: Model identifier to use.
-            messages: Messages to send to the LLM.
-            tools: Optional tools that the model may invoke.
-            format: Optional response format specifier.
-            **params: Additional parameters to configure output (e.g. temperature). See `llm.Params`.
-
-        Returns:
-            An `llm.Response` object containing the LLM-generated content.
-        """
-        mlx = _get_mlx(model_id)
-
-        input_messages, format, assistant_message, response = mlx.generate(
-            messages, tools, format, params
-        )
-
-        return Response(
-            raw=response,
-            provider_id="mlx",
-            model_id=model_id,
-            provider_model_name=model_id,
-            params=params,
-            tools=tools,
-            input_messages=input_messages,
-            assistant_message=assistant_message,
-            finish_reason=_utils.extract_finish_reason(response),
-            usage=_utils.extract_usage(response),
-            format=format,
-        )
-
-    def _context_call(
-        self,
-        *,
-        ctx: Context[DepsT],
-        model_id: MLXModelId,
-        messages: Sequence[Message],
-        tools: Sequence[Tool | ContextTool[DepsT]]
-        | ContextToolkit[DepsT]
-        | None = None,
-        format: type[FormattableT]
-        | Format[FormattableT]
-        | OutputParser[FormattableT]
-        | None = None,
-        **params: Unpack[Params],
-    ) -> ContextResponse[DepsT, None] | ContextResponse[DepsT, FormattableT]:
-        """Generate an `llm.ContextResponse` using MLX model.
-
-        Args:
-            ctx: Context object with dependencies for tools.
-            model_id: Model identifier to use.
-            messages: Messages to send to the LLM.
-            tools: Optional tools that the model may invoke.
-            format: Optional response format specifier.
-            **params: Additional parameters to configure output (e.g. temperature). See `llm.Params`.
-
-        Returns:
-            An `llm.ContextResponse` object containing the LLM-generated content.
-        """
-        mlx = _get_mlx(model_id)
-
-        input_messages, format, assistant_message, response = mlx.generate(
-            messages, tools, format, params
-        )
-
-        return ContextResponse(
-            raw=response,
-            provider_id="mlx",
-            model_id=model_id,
-            provider_model_name=model_id,
-            params=params,
-            tools=tools,
-            input_messages=input_messages,
-            assistant_message=assistant_message,
-            finish_reason=_utils.extract_finish_reason(response),
-            usage=_utils.extract_usage(response),
-            format=format,
-        )
-
-    async def _call_async(
-        self,
-        *,
-        model_id: MLXModelId,
-        messages: Sequence[Message],
-        tools: Sequence[AsyncTool] | AsyncToolkit | None = None,
-        format: type[FormattableT]
-        | Format[FormattableT]
-        | OutputParser[FormattableT]
-        | None = None,
-        **params: Unpack[Params],
-    ) -> AsyncResponse | AsyncResponse[FormattableT]:
-        """Generate an `llm.AsyncResponse` using MLX model by asynchronously calloing
-        `asycio.to_thread`.
-
-        Args:
-            model_id: Model identifier to use.
-            messages: Messages to send to the LLM.
-            tools: Optional tools that the model may invoke.
-            format: Optional response format specifier.
-            **params: Additional parameters to configure output (e.g. temperature). See `llm.Params`.
-
-        Returns:
-            An `llm.AsyncResponse` object containing the LLM-generated content.
-        """
-        mlx = _get_mlx(model_id)
-
-        (
-            input_messages,
-            format,
-            assistant_message,
-            response,
-        ) = await mlx.generate_async(messages, tools, format, params)
-
-        return AsyncResponse(
-            raw=response,
-            provider_id="mlx",
-            model_id=model_id,
-            provider_model_name=model_id,
-            params=params,
-            tools=tools,
-            input_messages=input_messages,
-            assistant_message=assistant_message,
-            finish_reason=_utils.extract_finish_reason(response),
-            usage=_utils.extract_usage(response),
-            format=format,
-        )
-
-    async def _context_call_async(
-        self,
-        *,
-        ctx: Context[DepsT],
-        model_id: MLXModelId,
-        messages: Sequence[Message],
-        tools: Sequence[AsyncTool | AsyncContextTool[DepsT]]
-        | AsyncContextToolkit[DepsT]
-        | None = None,
-        format: type[FormattableT]
-        | Format[FormattableT]
-        | OutputParser[FormattableT]
-        | None = None,
-        **params: Unpack[Params],
-    ) -> AsyncContextResponse[DepsT, None] | AsyncContextResponse[DepsT, FormattableT]:
-        """Generate an `llm.AsyncResponse` using MLX model by asynchronously calloing
-        `asycio.to_thread`.
-
-        Args:
-            ctx: Context object with dependencies for tools.
-            model_id: Model identifier to use.
-            messages: Messages to send to the LLM.
-            tools: Optional tools that the model may invoke.
-            format: Optional response format specifier.
-            **params: Additional parameters to configure output (e.g. temperature). See `llm.Params`.
-
-        Returns:
-            An `llm.AsyncContextResponse` object containing the LLM-generated content.
-        """
-        mlx = _get_mlx(model_id)
-
-        (
-            input_messages,
-            format,
-            assistant_message,
-            response,
-        ) = await mlx.generate_async(messages, tools, format, params)
-
-        return AsyncContextResponse(
-            raw=response,
-            provider_id="mlx",
-            model_id=model_id,
-            provider_model_name=model_id,
-            params=params,
-            tools=tools,
-            input_messages=input_messages,
-            assistant_message=assistant_message,
-            finish_reason=_utils.extract_finish_reason(response),
-            usage=_utils.extract_usage(response),
-            format=format,
-        )
-
-    def _stream(
-        self,
-        *,
-        model_id: MLXModelId,
-        messages: Sequence[Message],
-        tools: Sequence[Tool] | Toolkit | None = None,
-        format: type[FormattableT]
-        | Format[FormattableT]
-        | OutputParser[FormattableT]
-        | None = None,
-        **params: Unpack[Params],
-    ) -> StreamResponse | StreamResponse[FormattableT]:
-        """Generate an `llm.StreamResponse` by synchronously streaming from MLX model output.
-
-        Args:
-            model_id: Model identifier to use.
-            messages: Messages to send to the LLM.
-            tools: Optional tools that the model may invoke.
-            format: Optional response format specifier.
-            **params: Additional parameters to configure output (e.g. temperature). See `llm.Params`.
-
-        Returns:
-            An `llm.StreamResponse` object for iterating over the LLM-generated content.
-        """
-        mlx = _get_mlx(model_id)
-
-        input_messages, format, chunk_iterator = mlx.stream(
-            messages, tools, format, params
-        )
-
-        return StreamResponse(
-            provider_id="mlx",
-            model_id=model_id,
-            provider_model_name=model_id,
-            params=params,
-            tools=tools,
-            input_messages=input_messages,
-            chunk_iterator=chunk_iterator,
-            format=format,
-        )
-
-    def _context_stream(
-        self,
-        *,
-        ctx: Context[DepsT],
-        model_id: MLXModelId,
-        messages: Sequence[Message],
-        tools: Sequence[Tool | ContextTool[DepsT]]
-        | ContextToolkit[DepsT]
-        | None = None,
-        format: type[FormattableT]
-        | Format[FormattableT]
-        | OutputParser[FormattableT]
-        | None = None,
-        **params: Unpack[Params],
-    ) -> ContextStreamResponse[DepsT] | ContextStreamResponse[DepsT, FormattableT]:
-        """Generate an `llm.ContextStreamResponse` by synchronously streaming from MLX model output.
-
-        Args:
-            ctx: Context object with dependencies for tools.
-            model_id: Model identifier to use.
-            messages: Messages to send to the LLM.
-            tools: Optional tools that the model may invoke.
-            format: Optional response format specifier.
-            **params: Additional parameters to configure output (e.g. temperature). See `llm.Params`.
-
-        Returns:
-            An `llm.ContextStreamResponse` object for iterating over the LLM-generated content.
-        """
-        mlx = _get_mlx(model_id)
-
-        input_messages, format, chunk_iterator = mlx.stream(
-            messages, tools, format, params
-        )
-
-        return ContextStreamResponse(
-            provider_id="mlx",
-            model_id=model_id,
-            provider_model_name=model_id,
-            params=params,
-            tools=tools,
-            input_messages=input_messages,
-            chunk_iterator=chunk_iterator,
-            format=format,
-        )
-
-    async def _stream_async(
-        self,
-        *,
-        model_id: MLXModelId,
-        messages: Sequence[Message],
-        tools: Sequence[AsyncTool] | AsyncToolkit | None = None,
-        format: type[FormattableT]
-        | Format[FormattableT]
-        | OutputParser[FormattableT]
-        | None = None,
-        **params: Unpack[Params],
-    ) -> AsyncStreamResponse | AsyncStreamResponse[FormattableT]:
-        """Generate an `llm.AsyncStreamResponse` by asynchronously streaming from MLX model output.
-
-        Args:
-            model_id: Model identifier to use.
-            messages: Messages to send to the LLM.
-            tools: Optional tools that the model may invoke.
-            format: Optional response format specifier.
-            **params: Additional parameters to configure output (e.g. temperature). See `llm.Params`.
-
-        Returns:
-            An `llm.AsyncStreamResponse` object for asynchronously iterating over the LLM-generated content.
-        """
-        mlx = _get_mlx(model_id)
-
-        input_messages, format, chunk_iterator = await mlx.stream_async(
-            messages, tools, format, params
-        )
-
-        return AsyncStreamResponse(
-            provider_id="mlx",
-            model_id=model_id,
-            provider_model_name=model_id,
-            params=params,
-            tools=tools,
-            input_messages=input_messages,
-            chunk_iterator=chunk_iterator,
-            format=format,
-        )
-
-    async def _context_stream_async(
-        self,
-        *,
-        ctx: Context[DepsT],
-        model_id: MLXModelId,
-        messages: Sequence[Message],
-        tools: Sequence[AsyncTool | AsyncContextTool[DepsT]]
-        | AsyncContextToolkit[DepsT]
-        | None = None,
-        format: type[FormattableT]
-        | Format[FormattableT]
-        | OutputParser[FormattableT]
-        | None = None,
-        **params: Unpack[Params],
-    ) -> (
-        AsyncContextStreamResponse[DepsT]
-        | AsyncContextStreamResponse[DepsT, FormattableT]
-    ):
-        """Generate an `llm.AsyncContextStreamResponse` by asynchronously streaming from MLX model output.
-
-        Args:
-            ctx: Context object with dependencies for tools.
-            model_id: Model identifier to use.
-            messages: Messages to send to the LLM.
-            tools: Optional tools that the model may invoke.
-            format: Optional response format specifier.
-            **params: Additional parameters to configure output (e.g. temperature). See `llm.Params`.
-
-        Returns:
-            An `llm.AsyncContextStreamResponse` object for asynchronously iterating over the LLM-generated content.
-        """
-        mlx = _get_mlx(model_id)
-
-        input_messages, format, chunk_iterator = await mlx.stream_async(
-            messages, tools, format, params
-        )
-
-        return AsyncContextStreamResponse(
-            provider_id="mlx",
-            model_id=model_id,
-            provider_model_name=model_id,
-            params=params,
-            tools=tools,
-            input_messages=input_messages,
-            chunk_iterator=chunk_iterator,
-            format=format,
-        )

mirascope/llm/providers/model_id.py

@@ -1,16 +0,0 @@
-from typing import TypeAlias
-
-from .anthropic import (
-    AnthropicModelId,
-)
-from .google import (
-    GoogleModelId,
-)
-from .mlx import (
-    MLXModelId,
-)
-from .openai import (
-    OpenAIModelId,
-)
-
-ModelId: TypeAlias = AnthropicModelId | GoogleModelId | OpenAIModelId | MLXModelId | str

mirascope/llm/providers/ollama/__init__.py

@@ -1,7 +0,0 @@
-"""Ollama provider implementation."""
-
-from .provider import OllamaProvider
-
-__all__ = [
-    "OllamaProvider",
-]

mirascope/llm/providers/ollama/provider.py

@@ -1,71 +0,0 @@
-"""Ollama provider implementation."""
-
-import os
-from typing import ClassVar
-
-from openai import AsyncOpenAI, OpenAI
-
-from ..openai.completions.base_provider import BaseOpenAICompletionsProvider
-
-
-class OllamaProvider(BaseOpenAICompletionsProvider):
-    """Provider for Ollama's OpenAI-compatible API.
-
-    Inherits from BaseOpenAICompletionsProvider with Ollama-specific configuration:
-    - Uses Ollama's local API endpoint (default: http://localhost:11434/v1/)
-    - API key is not required (Ollama ignores API keys)
-    - Supports OLLAMA_BASE_URL environment variable
-
-    Usage:
-        Register the provider with model ID prefixes you want to use:
-
-        ```python
-        import llm
-
-        # Register for ollama models
-        llm.register_provider("ollama", "ollama/")
-
-        # Now you can use ollama models directly
-        @llm.call("ollama/llama2")
-        def my_prompt():
-            return [llm.messages.user("Hello!")]
-        ```
-    """
-
-    id: ClassVar[str] = "ollama"
-    default_scope: ClassVar[str | list[str]] = "ollama/"
-    default_base_url: ClassVar[str | None] = "http://localhost:11434/v1/"
-    api_key_env_var: ClassVar[str] = "OLLAMA_API_KEY"
-    api_key_required: ClassVar[bool] = False
-    provider_name: ClassVar[str | None] = "Ollama"
-
-    def __init__(
-        self,
-        *,
-        api_key: str | None = None,
-        base_url: str | None = None,
-    ) -> None:
-        """Initialize the Ollama provider.
-
-        Args:
-            api_key: API key (optional). Defaults to OLLAMA_API_KEY env var or 'ollama'.
-            base_url: Custom base URL. Defaults to OLLAMA_BASE_URL env var
-                or http://localhost:11434/v1/.
-        """
-        resolved_api_key = api_key or os.environ.get(self.api_key_env_var) or "ollama"
-        resolved_base_url = (
-            base_url or os.environ.get("OLLAMA_BASE_URL") or self.default_base_url
-        )
-
-        self.client = OpenAI(
-            api_key=resolved_api_key,
-            base_url=resolved_base_url,
-        )
-        self.async_client = AsyncOpenAI(
-            api_key=resolved_api_key,
-            base_url=resolved_base_url,
-        )
-
-    def _model_name(self, model_id: str) -> str:
-        """Strip 'ollama/' prefix from model ID for Ollama API."""
-        return model_id.removeprefix("ollama/")

mirascope/llm/providers/openai/__init__.py

@@ -1,15 +0,0 @@
-"""OpenAI client implementation."""
-
-from .completions.base_provider import BaseOpenAICompletionsProvider
-from .completions.provider import OpenAICompletionsProvider
-from .model_id import OpenAIModelId
-from .provider import OpenAIProvider
-from .responses.provider import OpenAIResponsesProvider
-
-__all__ = [
-    "BaseOpenAICompletionsProvider",
-    "OpenAICompletionsProvider",
-    "OpenAIModelId",
-    "OpenAIProvider",
-    "OpenAIResponsesProvider",
-]

mirascope/llm/providers/openai/_utils/__init__.py

@@ -1,5 +0,0 @@
-"""Shared OpenAI utilities."""
-
-from .errors import OPENAI_ERROR_MAP
-
-__all__ = ["OPENAI_ERROR_MAP"]

mirascope/llm/providers/openai/_utils/errors.py

@@ -1,46 +0,0 @@
-"""OpenAI error handling utilities."""
-
-from openai import (
-    APIConnectionError as OpenAIAPIConnectionError,
-    APIResponseValidationError as OpenAIAPIResponseValidationError,
-    APITimeoutError as OpenAIAPITimeoutError,
-    AuthenticationError as OpenAIAuthenticationError,
-    BadRequestError as OpenAIBadRequestError,
-    ConflictError as OpenAIConflictError,
-    InternalServerError as OpenAIInternalServerError,
-    NotFoundError as OpenAINotFoundError,
-    OpenAIError,
-    PermissionDeniedError as OpenAIPermissionDeniedError,
-    RateLimitError as OpenAIRateLimitError,
-    UnprocessableEntityError as OpenAIUnprocessableEntityError,
-)
-
-from ....exceptions import (
-    AuthenticationError,
-    BadRequestError,
-    ConnectionError,
-    NotFoundError,
-    PermissionError,
-    ProviderError,
-    RateLimitError,
-    ResponseValidationError,
-    ServerError,
-    TimeoutError,
-)
-from ...base import ProviderErrorMap
-
-# Shared error mapping used by OpenAI Responses and Completions providers
-OPENAI_ERROR_MAP: ProviderErrorMap = {
-    OpenAIAuthenticationError: AuthenticationError,
-    OpenAIPermissionDeniedError: PermissionError,
-    OpenAINotFoundError: NotFoundError,
-    OpenAIBadRequestError: BadRequestError,
-    OpenAIUnprocessableEntityError: BadRequestError,
-    OpenAIConflictError: BadRequestError,
-    OpenAIRateLimitError: RateLimitError,
-    OpenAIInternalServerError: ServerError,
-    OpenAIAPITimeoutError: TimeoutError,
-    OpenAIAPIConnectionError: ConnectionError,
-    OpenAIAPIResponseValidationError: ResponseValidationError,
-    OpenAIError: ProviderError,  # Catch-all for unknown OpenAI errors
-}

mirascope/llm/providers/openai/completions/__init__.py

@@ -1,7 +0,0 @@
-from .base_provider import BaseOpenAICompletionsProvider
-from .provider import OpenAICompletionsProvider
-
-__all__ = [
-    "BaseOpenAICompletionsProvider",
-    "OpenAICompletionsProvider",
-]