mirascope 2.0.0a5__py3-none-any.whl → 2.0.1__py3-none-any.whl

mirascope/llm/providers/mirascope/provider.py

@@ -0,0 +1,349 @@
+"""Mirascope Router provider that routes requests through the Mirascope Router API."""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Sequence
+from typing import TYPE_CHECKING
+from typing_extensions import Unpack
+
+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, Provider
+from . import _utils
+
+if TYPE_CHECKING:
+    from ...models import Params
+
+
+class MirascopeProvider(BaseProvider[None]):
+    """Provider that routes LLM requests through the Mirascope Router API.
+
+    The Mirascope Router provides a unified API for multiple LLM providers
+    (Anthropic, Google, OpenAI) with usage tracking and cost calculation.
+
+    This provider:
+    - Takes model IDs in the format "scope/model-name" (e.g., "openai/gpt-4")
+    - Routes requests to the Mirascope Router endpoint
+    - Delegates to the appropriate underlying provider (Anthropic, Google, or OpenAI)
+    - Uses MIRASCOPE_API_KEY for authentication
+
+    Environment Variables:
+        MIRASCOPE_API_KEY: Required API key for Mirascope Router authentication
+        MIRASCOPE_ROUTER_BASE_URL: Optional base URL override
+            (default: https://mirascope.com/router/v2)
+
+    Example:
+        ```python
+        import os
+        from mirascope import llm
+
+        os.environ["MIRASCOPE_API_KEY"] = "mk..."
+
+        # Register the Mirascope provider
+        llm.register_provider(
+            "mirascope",
+            scope=["anthropic/", "google/", "openai/"],
+        )
+
+        # Use with llm.call decorator
+        @llm.call("openai/gpt-4")
+        def recommend_book(genre: str):
+            return f"Recommend a {genre} book"
+
+        response = recommend_book("fantasy")
+        print(response.content)
+        ```
+    """
+
+    id = "mirascope"
+    default_scope = ["anthropic/", "google/", "openai/"]
+    error_map = {}
+    """Empty error map since MirascopeProvider delegates to underlying providers.
+
+    Error handling is performed by the underlying provider instances (Anthropic,
+    Google, OpenAI), which have their own error maps. Any exceptions that bubble
+    up from underlying providers are already converted to Mirascope exceptions.
+    """
+
+    def __init__(
+        self, *, api_key: str | None = None, base_url: str | None = None
+    ) -> None:
+        """Initialize the Mirascope provider.
+
+        Args:
+            api_key: Mirascope API key. If not provided, reads from MIRASCOPE_API_KEY
+                environment variable.
+            base_url: Optional base URL override for the Mirascope Router. If not
+                provided, reads from MIRASCOPE_ROUTER_BASE_URL environment variable
+                or defaults to https://mirascope.com/router/v2
+        """
+        api_key = api_key or os.environ.get("MIRASCOPE_API_KEY")
+        if not api_key:
+            raise ValueError(
+                "Mirascope API key not found. "
+                "Set MIRASCOPE_API_KEY environment variable or pass api_key parameter."
+            )
+
+        self.api_key = api_key
+        self.router_base_url = base_url or _utils.get_default_router_base_url()
+        self.client = None  # No single client; we create per-provider clients
+
+    def get_error_status(self, e: Exception) -> int | None:
+        """Extract HTTP status code from exception.
+
+        Since MirascopeProvider delegates to underlying providers, this method
+        is not used for direct error extraction. Underlying providers handle
+        their own status code extraction.
+
+        Args:
+            e: The exception to extract status code from.
+
+        Returns:
+            None, as status extraction is handled by underlying providers.
+        """
+        return None
+
+    def _get_underlying_provider(self, model_id: str) -> Provider:
+        """Get the underlying provider for a model ID.
+
+        Args:
+            model_id: Model identifier in format "scope/model-name"
+
+        Returns:
+            The appropriate cached provider instance (Anthropic, Google, or OpenAI)
+
+        Raises:
+            ValueError: If the model ID format is invalid or provider is unsupported
+        """
+        model_scope = _utils.extract_model_scope(model_id)
+        if not model_scope:
+            raise ValueError(
+                f"Invalid model ID format: {model_id}. "
+                f"Expected format 'scope/model-name' (e.g., 'openai/gpt-4')"
+            )
+
+        # Use the cached function to get/create the provider
+        return _utils.create_underlying_provider(
+            model_scope=model_scope,
+            api_key=self.api_key,
+            router_base_url=self.router_base_url,
+        )
+
+    def _call(
+        self,
+        *,
+        model_id: str,
+        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` by calling through the Mirascope Router."""
+        provider = self._get_underlying_provider(model_id)
+        return provider.call(
+            model_id=model_id,
+            messages=messages,
+            tools=tools,
+            format=format,
+            **params,
+        )
+
+    def _context_call(
+        self,
+        *,
+        ctx: Context[DepsT],
+        model_id: str,
+        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` by calling through the Mirascope Router."""
+        provider = self._get_underlying_provider(model_id)
+        return provider.context_call(
+            ctx=ctx,
+            model_id=model_id,
+            messages=messages,
+            tools=tools,
+            format=format,
+            **params,
+        )
+
+    async def _call_async(
+        self,
+        *,
+        model_id: str,
+        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` by calling through the Mirascope Router."""
+        provider = self._get_underlying_provider(model_id)
+        return await provider.call_async(
+            model_id=model_id,
+            messages=messages,
+            tools=tools,
+            format=format,
+            **params,
+        )
+
+    async def _context_call_async(
+        self,
+        *,
+        ctx: Context[DepsT],
+        model_id: str,
+        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.AsyncContextResponse` by calling through the Mirascope Router."""
+        provider = self._get_underlying_provider(model_id)
+        return await provider.context_call_async(
+            ctx=ctx,
+            model_id=model_id,
+            messages=messages,
+            tools=tools,
+            format=format,
+            **params,
+        )
+
+    def _stream(
+        self,
+        *,
+        model_id: str,
+        messages: Sequence[Message],
+        tools: Sequence[Tool] | Toolkit | None = None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None = None,
+        **params: Unpack[Params],
+    ) -> StreamResponse | StreamResponse[FormattableT]:
+        """Stream an `llm.StreamResponse` by calling through the Mirascope Router."""
+        provider = self._get_underlying_provider(model_id)
+        return provider.stream(
+            model_id=model_id,
+            messages=messages,
+            tools=tools,
+            format=format,
+            **params,
+        )
+
+    def _context_stream(
+        self,
+        *,
+        ctx: Context[DepsT],
+        model_id: str,
+        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, None] | ContextStreamResponse[DepsT, FormattableT]
+    ):
+        """Stream an `llm.ContextStreamResponse` by calling through the Mirascope Router."""
+        provider = self._get_underlying_provider(model_id)
+        return provider.context_stream(
+            ctx=ctx,
+            model_id=model_id,
+            messages=messages,
+            tools=tools,
+            format=format,
+            **params,
+        )
+
+    async def _stream_async(
+        self,
+        *,
+        model_id: str,
+        messages: Sequence[Message],
+        tools: Sequence[AsyncTool] | AsyncToolkit | None = None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None = None,
+        **params: Unpack[Params],
+    ) -> AsyncStreamResponse | AsyncStreamResponse[FormattableT]:
+        """Stream an `llm.AsyncStreamResponse` by calling through the Mirascope Router."""
+        provider = self._get_underlying_provider(model_id)
+        return await provider.stream_async(
+            model_id=model_id,
+            messages=messages,
+            tools=tools,
+            format=format,
+            **params,
+        )
+
+    async def _context_stream_async(
+        self,
+        *,
+        ctx: Context[DepsT],
+        model_id: str,
+        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, None]
+        | AsyncContextStreamResponse[DepsT, FormattableT]
+    ):
+        """Stream an `llm.AsyncContextStreamResponse` by calling through the Mirascope Router."""
+        provider = self._get_underlying_provider(model_id)
+        return await provider.context_stream_async(
+            ctx=ctx,
+            model_id=model_id,
+            messages=messages,
+            tools=tools,
+            format=format,
+            **params,
+        )

mirascope/llm/providers/mlx/__init__.py

@@ -1,22 +1,7 @@
 """MLX client implementation."""
 
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from .model_id import MLXModelId
-    from .provider import MLXProvider
-else:
-    try:
-        from .model_id import MLXModelId
-        from .provider import MLXProvider
-    except ImportError:  # pragma: no cover
-        from .._missing_import_stubs import (
-            create_import_error_stub,
-            create_provider_stub,
-        )
-
-        MLXProvider = create_provider_stub("mlx", "MLXProvider")
-        MLXModelId = str
+from .model_id import MLXModelId
+from .provider import MLXProvider
 
 __all__ = [
     "MLXModelId",

mirascope/llm/providers/mlx/_utils.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 from collections.abc import Callable
-from typing import TypeAlias, TypedDict
+from typing import TYPE_CHECKING, TypeAlias, TypedDict
 
 import mlx.core as mx
 from huggingface_hub.errors import LocalEntryNotFoundError
@@ -8,7 +10,10 @@ from mlx_lm.sample_utils import make_sampler
 
 from ...exceptions import NotFoundError
 from ...responses import FinishReason, Usage
-from ..base import Params, ProviderErrorMap, _utils as _base_utils
+from ..base import ProviderErrorMap, _utils as _base_utils
+
+if TYPE_CHECKING:
+    from ...models import Params
 
 Sampler: TypeAlias = Callable[[mx.array], mx.array]
 
@@ -76,7 +81,7 @@ def encode_params(params: Params) -> tuple[int | None, StreamGenerateKwargs]:
     with _base_utils.ensure_all_params_accessed(
         params=params,
         provider_id="mlx",
-        unsupported_params=["stop_sequences", "thinking", "encode_thoughts_as_text"],
+        unsupported_params=["stop_sequences", "thinking"],
     ) as param_accessor:
         if param_accessor.max_tokens is not None:
             kwargs["max_tokens"] = param_accessor.max_tokens

mirascope/llm/providers/mlx/encoding/base.py

@@ -6,7 +6,7 @@ from typing import TypeAlias
 
 from mlx_lm.generate import GenerationResponse
 
-from ....formatting import Format, FormattableT
+from ....formatting import Format, FormattableT, OutputParser
 from ....messages import AssistantContent, Message
 from ....responses import ChunkIterator
 from ....tools import AnyToolSchema, BaseToolkit
@@ -22,7 +22,10 @@ class BaseEncoder(abc.ABC):
         self,
         messages: Sequence[Message],
         tools: Sequence[AnyToolSchema] | BaseToolkit[AnyToolSchema] | None,
-        format: type[FormattableT] | Format[FormattableT] | None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None,
     ) -> tuple[Sequence[Message], Format[FormattableT] | None, TokenIds]:
         """Encode the request messages into a format suitable for the model.
 

mirascope/llm/providers/mlx/encoding/transformers.py

@@ -8,7 +8,7 @@ from mlx_lm.generate import GenerationResponse
 from transformers import PreTrainedTokenizer
 
 from ....content import ContentPart, TextChunk, TextEndChunk, TextStartChunk
-from ....formatting import Format, FormattableT
+from ....formatting import Format, FormattableT, OutputParser
 from ....messages import AssistantContent, Message
 from ....responses import (
     ChunkIterator,
@@ -81,7 +81,10 @@ class TransformersEncoder(BaseEncoder):
         self,
         messages: Sequence[Message],
         tools: Sequence[AnyToolSchema] | BaseToolkit[AnyToolSchema] | None,
-        format: type[FormattableT] | Format[FormattableT] | None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None,
     ) -> tuple[Sequence[Message], Format[FormattableT] | None, TokenIds]:
         """Encode a request into a format suitable for the model."""
         tool_schemas = tools.tools if isinstance(tools, BaseToolkit) else tools or []

mirascope/llm/providers/mlx/mlx.py

@@ -1,7 +1,10 @@
+from __future__ import annotations
+
 import asyncio
 import threading
 from collections.abc import Iterable, Sequence
 from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
 from typing_extensions import Unpack
 
 import mlx.core as mx
@@ -10,15 +13,17 @@ from mlx_lm import stream_generate  # type: ignore[reportPrivateImportUsage]
 from mlx_lm.generate import GenerationResponse
 from transformers import PreTrainedTokenizer
 
-from ...formatting import Format, FormattableT
+from ...formatting import Format, FormattableT, OutputParser
 from ...messages import AssistantMessage, Message, assistant
 from ...responses import AsyncChunkIterator, ChunkIterator, StreamResponseChunk
 from ...tools import AnyToolSchema, BaseToolkit
-from ..base import Params
 from . import _utils
 from .encoding import BaseEncoder, TokenIds
 from .model_id import MLXModelId
 
+if TYPE_CHECKING:
+    from ...models import Params
+
 
 def _consume_sync_stream_into_queue(
     generation_stream: ChunkIterator,
@@ -133,7 +138,10 @@ class MLX:
         self,
         messages: Sequence[Message],
         tools: Sequence[AnyToolSchema] | BaseToolkit[AnyToolSchema] | None,
-        format: type[FormattableT] | Format[FormattableT] | None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None,
         params: Params,
     ) -> tuple[Sequence[Message], Format[FormattableT] | None, ChunkIterator]:
         """Stream response chunks synchronously.
@@ -156,7 +164,10 @@ class MLX:
         self,
         messages: Sequence[Message],
         tools: Sequence[AnyToolSchema] | BaseToolkit[AnyToolSchema] | None,
-        format: type[FormattableT] | Format[FormattableT] | None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None,
         params: Params,
     ) -> tuple[Sequence[Message], Format[FormattableT] | None, AsyncChunkIterator]:
         """Stream response chunks asynchronously.
@@ -180,7 +191,10 @@ class MLX:
         self,
         messages: Sequence[Message],
         tools: Sequence[AnyToolSchema] | BaseToolkit[AnyToolSchema] | None,
-        format: type[FormattableT] | Format[FormattableT] | None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None,
         params: Params,
     ) -> tuple[
         Sequence[Message],
@@ -216,7 +230,10 @@ class MLX:
         self,
         messages: Sequence[Message],
         tools: Sequence[AnyToolSchema] | BaseToolkit[AnyToolSchema] | None,
-        format: type[FormattableT] | Format[FormattableT] | None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None,
         params: Params,
     ) -> tuple[
         Sequence[Message],

mirascope/llm/providers/mlx/provider.py

@@ -1,6 +1,8 @@
+from __future__ import annotations
+
 from collections.abc import Sequence
 from functools import cache, lru_cache
-from typing import cast
+from typing import TYPE_CHECKING, cast
 from typing_extensions import Unpack
 
 import mlx.nn as nn
@@ -8,7 +10,7 @@ from mlx_lm import load as mlx_load
 from transformers import PreTrainedTokenizer
 
 from ...context import Context, DepsT
-from ...formatting import Format, FormattableT
+from ...formatting import Format, FormattableT, OutputParser
 from ...messages import Message
 from ...responses import (
     AsyncContextResponse,
@@ -30,20 +32,23 @@ from ...tools import (
     Tool,
     Toolkit,
 )
-from ..base import BaseProvider, Params
+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":
+def _mlx_client_singleton() -> MLXProvider:
     """Get or create the singleton MLX client instance."""
     return MLXProvider()
 
 
-def client() -> "MLXProvider":
+def client() -> MLXProvider:
     """Get the MLX client singleton instance."""
     return _mlx_client_singleton()
 
@@ -85,7 +90,10 @@ class MLXProvider(BaseProvider[None]):
         model_id: MLXModelId,
         messages: Sequence[Message],
         tools: Sequence[Tool] | Toolkit | None = None,
-        format: type[FormattableT] | Format[FormattableT] | None = None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None = None,
         **params: Unpack[Params],
     ) -> Response | Response[FormattableT]:
         """Generate an `llm.Response` using MLX model.
@@ -129,7 +137,10 @@ class MLXProvider(BaseProvider[None]):
         tools: Sequence[Tool | ContextTool[DepsT]]
         | ContextToolkit[DepsT]
         | None = None,
-        format: type[FormattableT] | Format[FormattableT] | 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.
@@ -171,7 +182,10 @@ class MLXProvider(BaseProvider[None]):
         model_id: MLXModelId,
         messages: Sequence[Message],
         tools: Sequence[AsyncTool] | AsyncToolkit | None = None,
-        format: type[FormattableT] | Format[FormattableT] | 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
@@ -219,7 +233,10 @@ class MLXProvider(BaseProvider[None]):
         tools: Sequence[AsyncTool | AsyncContextTool[DepsT]]
         | AsyncContextToolkit[DepsT]
         | None = None,
-        format: type[FormattableT] | Format[FormattableT] | 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
@@ -265,7 +282,10 @@ class MLXProvider(BaseProvider[None]):
         model_id: MLXModelId,
         messages: Sequence[Message],
         tools: Sequence[Tool] | Toolkit | None = None,
-        format: type[FormattableT] | Format[FormattableT] | 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.
@@ -306,7 +326,10 @@ class MLXProvider(BaseProvider[None]):
         tools: Sequence[Tool | ContextTool[DepsT]]
         | ContextToolkit[DepsT]
         | None = None,
-        format: type[FormattableT] | Format[FormattableT] | 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.
@@ -345,7 +368,10 @@ class MLXProvider(BaseProvider[None]):
         model_id: MLXModelId,
         messages: Sequence[Message],
         tools: Sequence[AsyncTool] | AsyncToolkit | None = None,
-        format: type[FormattableT] | Format[FormattableT] | 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.
@@ -386,7 +412,10 @@ class MLXProvider(BaseProvider[None]):
         tools: Sequence[AsyncTool | AsyncContextTool[DepsT]]
         | AsyncContextToolkit[DepsT]
         | None = None,
-        format: type[FormattableT] | Format[FormattableT] | None = None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None = None,
         **params: Unpack[Params],
     ) -> (
         AsyncContextStreamResponse[DepsT]

mirascope/llm/providers/ollama/__init__.py

@@ -1,18 +1,6 @@
 """Ollama provider implementation."""
 
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from .provider import OllamaProvider
-else:
-    try:
-        from .provider import OllamaProvider
-    except ImportError:  # pragma: no cover
-        from .._missing_import_stubs import (
-            create_provider_stub,
-        )
-
-        OllamaProvider = create_provider_stub("openai", "OllamaProvider")
+from .provider import OllamaProvider
 
 __all__ = [
     "OllamaProvider",