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

mirascope/llm/providers/anthropic/provider.py

@@ -1,479 +0,0 @@
-"""Anthropic client implementation."""
-
-from __future__ import annotations
-
-from collections.abc import Sequence
-from typing import TYPE_CHECKING
-from typing_extensions import Unpack
-
-from anthropic import Anthropic, AsyncAnthropic
-
-from ...context import Context, DepsT
-from ...formatting import Format, FormattableT, OutputParser, resolve_format
-from ...messages import Message
-from ...responses import (
-    AsyncContextResponse,
-    AsyncContextStreamResponse,
-    AsyncResponse,
-    AsyncStreamResponse,
-    ContextResponse,
-    ContextStreamResponse,
-    Response,
-    StreamResponse,
-)
-from ...tools import (
-    AnyToolSchema,
-    AsyncContextTool,
-    AsyncContextToolkit,
-    AsyncTool,
-    AsyncToolkit,
-    BaseToolkit,
-    ContextTool,
-    ContextToolkit,
-    Tool,
-    Toolkit,
-)
-from ..base import BaseProvider, _utils as _base_utils
-from . import _utils
-from .beta_provider import AnthropicBetaProvider
-from .model_id import AnthropicModelId, model_name
-from .model_info import MODELS_WITHOUT_STRICT_STRUCTURED_OUTPUTS
-
-if TYPE_CHECKING:
-    from ...models import Params
-
-
-def _should_use_beta(
-    model_id: AnthropicModelId,
-    format: type[FormattableT]
-    | Format[FormattableT]
-    | OutputParser[FormattableT]
-    | None,
-    tools: Sequence[AnyToolSchema] | BaseToolkit[AnyToolSchema] | None,
-) -> bool:
-    """Determine whether to use the beta API based on format mode or strict tools.
-
-    If the format resolves to strict mode, or any tools have strict=True,
-    and the model plausibly has strict structured output support, then we
-    will use the beta provider.
-    """
-    if model_name(model_id) in MODELS_WITHOUT_STRICT_STRUCTURED_OUTPUTS:
-        return False
-
-    # Check if format requires strict mode
-    resolved = resolve_format(format, default_mode=_utils.DEFAULT_FORMAT_MODE)
-    if resolved is not None and resolved.mode == "strict":
-        return True
-
-    return _base_utils.has_strict_tools(tools)
-
-
-class AnthropicProvider(BaseProvider[Anthropic]):
-    """The client for the Anthropic LLM model."""
-
-    id = "anthropic"
-    default_scope = "anthropic/"
-    error_map = _utils.ANTHROPIC_ERROR_MAP
-    _beta_provider: AnthropicBetaProvider
-
-    def __init__(
-        self, *, api_key: str | None = None, base_url: str | None = None
-    ) -> None:
-        """Initialize the Anthropic client."""
-        self.client = Anthropic(api_key=api_key, base_url=base_url)
-        self.async_client = AsyncAnthropic(api_key=api_key, base_url=base_url)
-        self._beta_provider = AnthropicBetaProvider(api_key=api_key, base_url=base_url)
-
-    def get_error_status(self, e: Exception) -> int | None:
-        """Extract HTTP status code from Anthropic exception."""
-        return getattr(e, "status_code", None)
-
-    def _call(
-        self,
-        *,
-        model_id: AnthropicModelId,
-        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 synchronously calling the Anthropic Messages API."""
-        if _should_use_beta(model_id, format, tools):
-            return self._beta_provider.call(
-                model_id=model_id,
-                messages=messages,
-                tools=tools,
-                format=format,
-                **params,
-            )
-
-        input_messages, resolved_format, kwargs = _utils.encode_request(
-            model_id=model_id,
-            messages=messages,
-            tools=tools,
-            format=format,
-            params=params,
-        )
-        anthropic_response = self.client.messages.create(**kwargs)
-        include_thoughts = _utils.get_include_thoughts(params)
-        assistant_message, finish_reason, usage = _utils.decode_response(
-            anthropic_response, model_id, include_thoughts=include_thoughts
-        )
-        return Response(
-            raw=anthropic_response,
-            provider_id="anthropic",
-            model_id=model_id,
-            provider_model_name=model_name(model_id),
-            params=params,
-            tools=tools,
-            input_messages=input_messages,
-            assistant_message=assistant_message,
-            finish_reason=finish_reason,
-            usage=usage,
-            format=resolved_format,
-        )
-
-    def _context_call(
-        self,
-        *,
-        ctx: Context[DepsT],
-        model_id: AnthropicModelId,
-        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 synchronously calling the Anthropic Messages API."""
-        if _should_use_beta(model_id, format, tools):
-            return self._beta_provider.context_call(
-                ctx=ctx,
-                model_id=model_id,
-                messages=messages,
-                tools=tools,
-                format=format,
-                **params,
-            )
-
-        input_messages, resolved_format, kwargs = _utils.encode_request(
-            model_id=model_id,
-            messages=messages,
-            tools=tools,
-            format=format,
-            params=params,
-        )
-        anthropic_response = self.client.messages.create(**kwargs)
-        include_thoughts = _utils.get_include_thoughts(params)
-        assistant_message, finish_reason, usage = _utils.decode_response(
-            anthropic_response, model_id, include_thoughts=include_thoughts
-        )
-        return ContextResponse(
-            raw=anthropic_response,
-            provider_id="anthropic",
-            model_id=model_id,
-            provider_model_name=model_name(model_id),
-            params=params,
-            tools=tools,
-            input_messages=input_messages,
-            assistant_message=assistant_message,
-            finish_reason=finish_reason,
-            usage=usage,
-            format=resolved_format,
-        )
-
-    async def _call_async(
-        self,
-        *,
-        model_id: AnthropicModelId,
-        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 asynchronously calling the Anthropic Messages API."""
-        if _should_use_beta(model_id, format, tools):
-            return await self._beta_provider.call_async(
-                model_id=model_id,
-                messages=messages,
-                tools=tools,
-                format=format,
-                **params,
-            )
-
-        input_messages, resolved_format, kwargs = _utils.encode_request(
-            model_id=model_id,
-            messages=messages,
-            tools=tools,
-            format=format,
-            params=params,
-        )
-        anthropic_response = await self.async_client.messages.create(**kwargs)
-        include_thoughts = _utils.get_include_thoughts(params)
-        assistant_message, finish_reason, usage = _utils.decode_response(
-            anthropic_response, model_id, include_thoughts=include_thoughts
-        )
-        return AsyncResponse(
-            raw=anthropic_response,
-            provider_id="anthropic",
-            model_id=model_id,
-            provider_model_name=model_name(model_id),
-            params=params,
-            tools=tools,
-            input_messages=input_messages,
-            assistant_message=assistant_message,
-            finish_reason=finish_reason,
-            usage=usage,
-            format=resolved_format,
-        )
-
-    async def _context_call_async(
-        self,
-        *,
-        ctx: Context[DepsT],
-        model_id: AnthropicModelId,
-        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 asynchronously calling the Anthropic Messages API."""
-        if _should_use_beta(model_id, format, tools):
-            return await self._beta_provider.context_call_async(
-                ctx=ctx,
-                model_id=model_id,
-                messages=messages,
-                tools=tools,
-                format=format,
-                **params,
-            )
-
-        input_messages, resolved_format, kwargs = _utils.encode_request(
-            model_id=model_id,
-            messages=messages,
-            tools=tools,
-            format=format,
-            params=params,
-        )
-        anthropic_response = await self.async_client.messages.create(**kwargs)
-        include_thoughts = _utils.get_include_thoughts(params)
-        assistant_message, finish_reason, usage = _utils.decode_response(
-            anthropic_response, model_id, include_thoughts=include_thoughts
-        )
-        return AsyncContextResponse(
-            raw=anthropic_response,
-            provider_id="anthropic",
-            model_id=model_id,
-            provider_model_name=model_name(model_id),
-            params=params,
-            tools=tools,
-            input_messages=input_messages,
-            assistant_message=assistant_message,
-            finish_reason=finish_reason,
-            usage=usage,
-            format=resolved_format,
-        )
-
-    def _stream(
-        self,
-        *,
-        model_id: AnthropicModelId,
-        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 the Anthropic Messages API."""
-        if _should_use_beta(model_id, format, tools):
-            return self._beta_provider.stream(
-                model_id=model_id,
-                messages=messages,
-                tools=tools,
-                format=format,
-                **params,
-            )
-
-        input_messages, resolved_format, kwargs = _utils.encode_request(
-            model_id=model_id,
-            messages=messages,
-            tools=tools,
-            format=format,
-            params=params,
-        )
-        anthropic_stream = self.client.messages.stream(**kwargs)
-        include_thoughts = _utils.get_include_thoughts(params)
-        chunk_iterator = _utils.decode_stream(
-            anthropic_stream, include_thoughts=include_thoughts
-        )
-        return StreamResponse(
-            provider_id="anthropic",
-            model_id=model_id,
-            provider_model_name=model_name(model_id),
-            params=params,
-            tools=tools,
-            input_messages=input_messages,
-            chunk_iterator=chunk_iterator,
-            format=resolved_format,
-        )
-
-    def _context_stream(
-        self,
-        *,
-        ctx: Context[DepsT],
-        model_id: AnthropicModelId,
-        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 the Anthropic Messages API."""
-        if _should_use_beta(model_id, format, tools):
-            return self._beta_provider.context_stream(
-                ctx=ctx,
-                model_id=model_id,
-                messages=messages,
-                tools=tools,
-                format=format,
-                **params,
-            )
-
-        input_messages, resolved_format, kwargs = _utils.encode_request(
-            model_id=model_id,
-            messages=messages,
-            tools=tools,
-            format=format,
-            params=params,
-        )
-        anthropic_stream = self.client.messages.stream(**kwargs)
-        include_thoughts = _utils.get_include_thoughts(params)
-        chunk_iterator = _utils.decode_stream(
-            anthropic_stream, include_thoughts=include_thoughts
-        )
-        return ContextStreamResponse(
-            provider_id="anthropic",
-            model_id=model_id,
-            provider_model_name=model_name(model_id),
-            params=params,
-            tools=tools,
-            input_messages=input_messages,
-            chunk_iterator=chunk_iterator,
-            format=resolved_format,
-        )
-
-    async def _stream_async(
-        self,
-        *,
-        model_id: AnthropicModelId,
-        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 the Anthropic Messages API."""
-        if _should_use_beta(model_id, format, tools):
-            return await self._beta_provider.stream_async(
-                model_id=model_id,
-                messages=messages,
-                tools=tools,
-                format=format,
-                **params,
-            )
-        input_messages, resolved_format, kwargs = _utils.encode_request(
-            model_id=model_id,
-            messages=messages,
-            tools=tools,
-            format=format,
-            params=params,
-        )
-        anthropic_stream = self.async_client.messages.stream(**kwargs)
-        include_thoughts = _utils.get_include_thoughts(params)
-        chunk_iterator = _utils.decode_async_stream(
-            anthropic_stream, include_thoughts=include_thoughts
-        )
-        return AsyncStreamResponse(
-            provider_id="anthropic",
-            model_id=model_id,
-            provider_model_name=model_name(model_id),
-            params=params,
-            tools=tools,
-            input_messages=input_messages,
-            chunk_iterator=chunk_iterator,
-            format=resolved_format,
-        )
-
-    async def _context_stream_async(
-        self,
-        *,
-        ctx: Context[DepsT],
-        model_id: AnthropicModelId,
-        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 the Anthropic Messages API."""
-        if _should_use_beta(model_id, format, tools):
-            return await self._beta_provider.context_stream_async(
-                ctx=ctx,
-                model_id=model_id,
-                messages=messages,
-                tools=tools,
-                format=format,
-                **params,
-            )
-
-        input_messages, resolved_format, kwargs = _utils.encode_request(
-            model_id=model_id,
-            messages=messages,
-            tools=tools,
-            format=format,
-            params=params,
-        )
-        anthropic_stream = self.async_client.messages.stream(**kwargs)
-        include_thoughts = _utils.get_include_thoughts(params)
-        chunk_iterator = _utils.decode_async_stream(
-            anthropic_stream, include_thoughts=include_thoughts
-        )
-        return AsyncContextStreamResponse(
-            provider_id="anthropic",
-            model_id=model_id,
-            provider_model_name=model_name(model_id),
-            params=params,
-            tools=tools,
-            input_messages=input_messages,
-            chunk_iterator=chunk_iterator,
-            format=resolved_format,
-        )

mirascope/llm/providers/google/__init__.py

@@ -1,6 +0,0 @@
-"""Google client implementation."""
-
-from .model_id import GoogleModelId
-from .provider import GoogleProvider
-
-__all__ = ["GoogleModelId", "GoogleProvider"]

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

@@ -1,50 +0,0 @@
-"""Google error handling utilities."""
-
-from google.genai.errors import (
-    ClientError as GoogleClientError,
-    ServerError as GoogleServerError,
-)
-
-from ....exceptions import (
-    APIError,
-    AuthenticationError,
-    BadRequestError,
-    NotFoundError,
-    PermissionError,
-    ProviderError,
-    RateLimitError,
-    ServerError,
-)
-from ...base import ProviderErrorMap
-
-
-def map_google_error(e: Exception) -> type[ProviderError]:
-    """Map Google error to appropriate Mirascope error type.
-
-    Google only provides ClientError (4xx) and ServerError (5xx) with status codes,
-    so we map based on status code and message patterns.
-    """
-    if not isinstance(e, GoogleClientError | GoogleServerError):
-        return ProviderError
-
-    # Authentication errors (401) or 400 with "API key not valid"
-    if e.code == 401 or (e.code == 400 and "API key not valid" in str(e)):
-        return AuthenticationError
-    if e.code == 403:
-        return PermissionError
-    if e.code == 404:
-        return NotFoundError
-    if e.code == 429:
-        return RateLimitError
-    if e.code in (400, 422):
-        return BadRequestError
-    if isinstance(e, GoogleServerError) and e.code >= 500:
-        return ServerError
-    return APIError
-
-
-# Shared error mapping for Google provider
-GOOGLE_ERROR_MAP: ProviderErrorMap = {
-    GoogleClientError: map_google_error,
-    GoogleServerError: map_google_error,
-}

mirascope/llm/providers/google/model_id.py

@@ -1,22 +0,0 @@
-"""Google registered LLM models."""
-
-from typing import TypeAlias, get_args
-
-from .model_info import GoogleKnownModels
-
-GoogleModelId: TypeAlias = GoogleKnownModels | str
-"""The Google model ids registered with Mirascope."""
-
-GOOGLE_KNOWN_MODELS: set[str] = set(get_args(GoogleKnownModels))
-
-
-def model_name(model_id: GoogleModelId) -> str:
-    """Extract the google model name from a full model ID.
-
-    Args:
-        model_id: Full model ID (e.g. "google/gemini-2.5-flash")
-
-    Returns:
-        Provider-specific model ID (e.g. "gemini-2.5-flash")
-    """
-    return model_id.removeprefix("google/")

mirascope/llm/providers/google/model_info.py

@@ -1,63 +0,0 @@
-"""Google model information.
-
-This file is auto-generated by scripts/model_features/codegen_google.py
-Do not edit manually - run the codegen script to update."""
-
-from typing import Literal
-
-GoogleKnownModels = Literal[
-    "google/gemini-2.0-flash",
-    "google/gemini-2.0-flash-001",
-    "google/gemini-2.0-flash-exp",
-    "google/gemini-2.0-flash-exp-image-generation",
-    "google/gemini-2.0-flash-lite",
-    "google/gemini-2.0-flash-lite-001",
-    "google/gemini-2.0-flash-lite-preview",
-    "google/gemini-2.0-flash-lite-preview-02-05",
-    "google/gemini-2.5-flash",
-    "google/gemini-2.5-flash-image",
-    "google/gemini-2.5-flash-image-preview",
-    "google/gemini-2.5-flash-lite",
-    "google/gemini-2.5-flash-lite-preview-09-2025",
-    "google/gemini-2.5-flash-preview-09-2025",
-    "google/gemini-2.5-pro",
-    "google/gemini-3-flash-preview",
-    "google/gemini-3-pro-image-preview",
-    "google/gemini-3-pro-preview",
-    "google/gemini-flash-latest",
-    "google/gemini-flash-lite-latest",
-    "google/gemini-pro-latest",
-    "google/gemini-robotics-er-1.5-preview",
-    "google/gemma-3-12b-it",
-    "google/gemma-3-1b-it",
-    "google/gemma-3-27b-it",
-    "google/gemma-3-4b-it",
-    "google/gemma-3n-e2b-it",
-    "google/gemma-3n-e4b-it",
-    "google/nano-banana-pro-preview",
-]
-"""Valid Google model IDs."""
-
-
-MODELS_WITHOUT_STRUCTURED_OUTPUT_AND_TOOLS_SUPPORT: set[str] = {
-    "gemini-2.5-flash",
-    "gemini-2.5-flash-image",
-    "gemini-2.5-flash-image-preview",
-    "gemini-2.5-flash-lite",
-    "gemini-2.5-flash-lite-preview-09-2025",
-    "gemini-2.5-flash-preview-09-2025",
-    "gemini-2.5-pro",
-    "gemini-3-pro-image-preview",
-    "gemini-flash-latest",
-    "gemini-flash-lite-latest",
-    "gemini-pro-latest",
-    "gemini-robotics-er-1.5-preview",
-    "gemma-3-12b-it",
-    "gemma-3-1b-it",
-    "gemma-3-27b-it",
-    "gemma-3-4b-it",
-    "gemma-3n-e2b-it",
-    "gemma-3n-e4b-it",
-    "nano-banana-pro-preview",
-}
-"""Models that do not support structured outputs when tools are present."""