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

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

@@ -0,0 +1,46 @@
+"""Anthropic error handling utilities."""
+
+from anthropic import (
+    AnthropicError,
+    APIConnectionError as AnthropicAPIConnectionError,
+    APIResponseValidationError as AnthropicAPIResponseValidationError,
+    APITimeoutError as AnthropicAPITimeoutError,
+    AuthenticationError as AnthropicAuthenticationError,
+    BadRequestError as AnthropicBadRequestError,
+    ConflictError as AnthropicConflictError,
+    InternalServerError as AnthropicInternalServerError,
+    NotFoundError as AnthropicNotFoundError,
+    PermissionDeniedError as AnthropicPermissionDeniedError,
+    RateLimitError as AnthropicRateLimitError,
+    UnprocessableEntityError as AnthropicUnprocessableEntityError,
+)
+
+from ....exceptions import (
+    AuthenticationError,
+    BadRequestError,
+    ConnectionError,
+    NotFoundError,
+    PermissionError,
+    ProviderError,
+    RateLimitError,
+    ResponseValidationError,
+    ServerError,
+    TimeoutError,
+)
+from ...base import ProviderErrorMap
+
+# Shared error mapping used by both AnthropicProvider and AnthropicBetaProvider
+ANTHROPIC_ERROR_MAP: ProviderErrorMap = {
+    AnthropicAuthenticationError: AuthenticationError,
+    AnthropicPermissionDeniedError: PermissionError,
+    AnthropicBadRequestError: BadRequestError,
+    AnthropicUnprocessableEntityError: BadRequestError,
+    AnthropicNotFoundError: NotFoundError,
+    AnthropicConflictError: BadRequestError,
+    AnthropicRateLimitError: RateLimitError,
+    AnthropicInternalServerError: ServerError,
+    AnthropicAPITimeoutError: TimeoutError,
+    AnthropicAPIConnectionError: ConnectionError,
+    AnthropicAPIResponseValidationError: ResponseValidationError,
+    AnthropicError: ProviderError,  # Catch-all for unknown Anthropic errors
+}

mirascope/llm/providers/anthropic/beta_provider.py

@@ -0,0 +1,374 @@
+"""Beta Anthropic provider 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
+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 ._utils import beta_decode, beta_encode
+from .model_id import model_name
+
+if TYPE_CHECKING:
+    from ...models import Params
+
+
+class AnthropicBetaProvider(BaseProvider[Anthropic]):
+    """Provider using beta Anthropic API."""
+
+    id = "anthropic-beta"
+    default_scope = "anthropic-beta/"
+    error_map = _utils.ANTHROPIC_ERROR_MAP
+
+    def __init__(
+        self, *, api_key: str | None = None, base_url: str | None = None
+    ) -> None:
+        """Initialize the beta 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)
+
+    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: 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` using the beta Anthropic API."""
+        input_messages, resolved_format, kwargs = beta_encode.beta_encode_request(
+            model_id=model_id,
+            messages=messages,
+            tools=tools,
+            format=format,
+            params=params,
+        )
+        beta_response = self.client.beta.messages.parse(**kwargs)
+        include_thoughts = _utils.get_include_thoughts(params)
+        assistant_message, finish_reason, usage = beta_decode.beta_decode_response(
+            beta_response, model_id, include_thoughts=include_thoughts
+        )
+        return Response(
+            raw=beta_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: 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` using the beta Anthropic API."""
+        input_messages, resolved_format, kwargs = beta_encode.beta_encode_request(
+            model_id=model_id,
+            messages=messages,
+            tools=tools,
+            format=format,
+            params=params,
+        )
+        beta_response = self.client.beta.messages.parse(**kwargs)
+        include_thoughts = _utils.get_include_thoughts(params)
+        assistant_message, finish_reason, usage = beta_decode.beta_decode_response(
+            beta_response, model_id, include_thoughts=include_thoughts
+        )
+        return ContextResponse(
+            raw=beta_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: 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` using the beta Anthropic API."""
+        input_messages, resolved_format, kwargs = beta_encode.beta_encode_request(
+            model_id=model_id,
+            messages=messages,
+            tools=tools,
+            format=format,
+            params=params,
+        )
+        beta_response = await self.async_client.beta.messages.parse(**kwargs)
+        include_thoughts = _utils.get_include_thoughts(params)
+        assistant_message, finish_reason, usage = beta_decode.beta_decode_response(
+            beta_response, model_id, include_thoughts=include_thoughts
+        )
+        return AsyncResponse(
+            raw=beta_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: 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` using the beta Anthropic API."""
+        input_messages, resolved_format, kwargs = beta_encode.beta_encode_request(
+            model_id=model_id,
+            messages=messages,
+            tools=tools,
+            format=format,
+            params=params,
+        )
+        beta_response = await self.async_client.beta.messages.parse(**kwargs)
+        include_thoughts = _utils.get_include_thoughts(params)
+        assistant_message, finish_reason, usage = beta_decode.beta_decode_response(
+            beta_response, model_id, include_thoughts=include_thoughts
+        )
+        return AsyncContextResponse(
+            raw=beta_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: 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]:
+        """Generate an `llm.StreamResponse` using the beta Anthropic API."""
+        input_messages, resolved_format, kwargs = beta_encode.beta_encode_request(
+            model_id=model_id,
+            messages=messages,
+            tools=tools,
+            format=format,
+            params=params,
+        )
+        beta_stream = self.client.beta.messages.stream(**kwargs)
+        include_thoughts = _utils.get_include_thoughts(params)
+        chunk_iterator = beta_decode.beta_decode_stream(
+            beta_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: 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] | ContextStreamResponse[DepsT, FormattableT]:
+        """Generate an `llm.ContextStreamResponse` using the beta Anthropic API."""
+        input_messages, resolved_format, kwargs = beta_encode.beta_encode_request(
+            model_id=model_id,
+            messages=messages,
+            tools=tools,
+            format=format,
+            params=params,
+        )
+        beta_stream = self.client.beta.messages.stream(**kwargs)
+        include_thoughts = _utils.get_include_thoughts(params)
+        chunk_iterator = beta_decode.beta_decode_stream(
+            beta_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: 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]:
+        """Generate an `llm.AsyncStreamResponse` using the beta Anthropic API."""
+        input_messages, resolved_format, kwargs = beta_encode.beta_encode_request(
+            model_id=model_id,
+            messages=messages,
+            tools=tools,
+            format=format,
+            params=params,
+        )
+        beta_stream = self.async_client.beta.messages.stream(**kwargs)
+        include_thoughts = _utils.get_include_thoughts(params)
+        chunk_iterator = beta_decode.beta_decode_async_stream(
+            beta_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: 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]
+        | AsyncContextStreamResponse[DepsT, FormattableT]
+    ):
+        """Generate an `llm.AsyncContextStreamResponse` using the beta Anthropic API."""
+        input_messages, resolved_format, kwargs = beta_encode.beta_encode_request(
+            model_id=model_id,
+            messages=messages,
+            tools=tools,
+            format=format,
+            params=params,
+        )
+        beta_stream = self.async_client.beta.messages.stream(**kwargs)
+        include_thoughts = _utils.get_include_thoughts(params)
+        chunk_iterator = beta_decode.beta_decode_async_stream(
+            beta_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/anthropic/model_id.py

@@ -0,0 +1,23 @@
+"""Anthropic registered LLM models."""
+
+from typing import TypeAlias, get_args
+
+from .model_info import AnthropicKnownModels
+
+AnthropicModelId: TypeAlias = AnthropicKnownModels | str
+"""The Anthropic model ids registered with Mirascope."""
+
+ANTHROPIC_KNOWN_MODELS: set[str] = set(get_args(AnthropicKnownModels))
+
+
+def model_name(model_id: AnthropicModelId) -> str:
+    """Extract the anthropic model name from the ModelId
+
+    Args:
+        model_id: Full model ID (e.g. "anthropic/claude-sonnet-4-5" or
+            "anthropic-beta/claude-sonnet-4-5")
+
+    Returns:
+        Provider-specific model ID (e.g. "claude-sonnet-4-5")
+    """
+    return model_id.removeprefix("anthropic-beta/").removeprefix("anthropic/")

mirascope/llm/providers/anthropic/model_info.py

@@ -0,0 +1,87 @@
+"""Anthropic model information.
+
+This file is auto-generated by scripts/model_features/codegen_anthropic.py
+Do not edit manually - run the codegen script to update."""
+
+from typing import Literal
+
+AnthropicKnownModels = Literal[
+    "anthropic/claude-3-5-haiku",
+    "anthropic/claude-3-5-haiku-20241022",
+    "anthropic/claude-3-5-haiku-latest",
+    "anthropic/claude-3-7-sonnet",
+    "anthropic/claude-3-7-sonnet-20250219",
+    "anthropic/claude-3-7-sonnet-latest",
+    "anthropic/claude-3-haiku",
+    "anthropic/claude-3-haiku-20240307",
+    "anthropic/claude-3-haiku-latest",
+    "anthropic/claude-3-opus",
+    "anthropic/claude-3-opus-20240229",
+    "anthropic/claude-3-opus-latest",
+    "anthropic/claude-haiku-4-5",
+    "anthropic/claude-haiku-4-5-0",
+    "anthropic/claude-haiku-4-5-0-20251001",
+    "anthropic/claude-haiku-4-5-0-latest",
+    "anthropic/claude-haiku-4-5-20251001",
+    "anthropic/claude-haiku-4-5-latest",
+    "anthropic/claude-opus-4",
+    "anthropic/claude-opus-4-0",
+    "anthropic/claude-opus-4-0-20250514",
+    "anthropic/claude-opus-4-0-latest",
+    "anthropic/claude-opus-4-1",
+    "anthropic/claude-opus-4-1-0",
+    "anthropic/claude-opus-4-1-0-20250805",
+    "anthropic/claude-opus-4-1-0-latest",
+    "anthropic/claude-opus-4-1-20250805",
+    "anthropic/claude-opus-4-1-latest",
+    "anthropic/claude-opus-4-20250514",
+    "anthropic/claude-opus-4-5",
+    "anthropic/claude-opus-4-5-0",
+    "anthropic/claude-opus-4-5-0-20251101",
+    "anthropic/claude-opus-4-5-0-latest",
+    "anthropic/claude-opus-4-5-20251101",
+    "anthropic/claude-opus-4-5-latest",
+    "anthropic/claude-opus-4-latest",
+    "anthropic/claude-sonnet-4",
+    "anthropic/claude-sonnet-4-0",
+    "anthropic/claude-sonnet-4-0-20250514",
+    "anthropic/claude-sonnet-4-0-latest",
+    "anthropic/claude-sonnet-4-20250514",
+    "anthropic/claude-sonnet-4-5",
+    "anthropic/claude-sonnet-4-5-0",
+    "anthropic/claude-sonnet-4-5-0-20250929",
+    "anthropic/claude-sonnet-4-5-0-latest",
+    "anthropic/claude-sonnet-4-5-20250929",
+    "anthropic/claude-sonnet-4-5-latest",
+    "anthropic/claude-sonnet-4-latest",
+]
+"""Valid Anthropic model IDs."""
+
+
+MODELS_WITHOUT_STRICT_STRUCTURED_OUTPUTS: set[str] = {
+    "claude-3-5-haiku",
+    "claude-3-5-haiku-20241022",
+    "claude-3-5-haiku-latest",
+    "claude-3-7-sonnet",
+    "claude-3-7-sonnet-20250219",
+    "claude-3-7-sonnet-latest",
+    "claude-3-haiku",
+    "claude-3-haiku-20240307",
+    "claude-3-haiku-latest",
+    "claude-3-opus",
+    "claude-3-opus-20240229",
+    "claude-3-opus-latest",
+    "claude-opus-4",
+    "claude-opus-4-0",
+    "claude-opus-4-0-20250514",
+    "claude-opus-4-0-latest",
+    "claude-opus-4-20250514",
+    "claude-opus-4-latest",
+    "claude-sonnet-4",
+    "claude-sonnet-4-0",
+    "claude-sonnet-4-0-20250514",
+    "claude-sonnet-4-0-latest",
+    "claude-sonnet-4-20250514",
+    "claude-sonnet-4-latest",
+}
+"""Models that do not support strict structured outputs (strict mode tools)."""