mirascope 2.0.0a3__py3-none-any.whl → 2.0.0a5__py3-none-any.whl

mirascope/llm/providers/anthropic/provider.py

@@ -6,7 +6,7 @@ from typing_extensions import Unpack
 from anthropic import Anthropic, AsyncAnthropic
 
 from ...context import Context, DepsT
-from ...formatting import Format, FormattableT
+from ...formatting import Format, FormattableT, resolve_format
 from ...messages import Message
 from ...responses import (
     AsyncContextResponse,
@@ -30,7 +30,24 @@ from ...tools import (
 )
 from ..base import BaseProvider, Params
 from . import _utils
+from .beta_provider import AnthropicBetaProvider
 from .model_id import AnthropicModelId, model_name
+from .model_info import MODELS_WITHOUT_STRICT_STRUCTURED_OUTPUTS
+
+
+def _should_use_beta(
+    model_id: AnthropicModelId,
+    format: type[FormattableT] | Format[FormattableT] | None,
+) -> bool:
+    """Determine whether to use the beta API based on format mode.
+
+    If the format resolves to strict mode, and the model plausibly has
+    strict structured output support, then we will use the beta provider.
+    """
+    resolved = resolve_format(format, default_mode=_utils.DEFAULT_FORMAT_MODE)
+    if resolved is None or resolved.mode != "strict":
+        return False
+    return model_name(model_id) not in MODELS_WITHOUT_STRICT_STRUCTURED_OUTPUTS
 
 
 class AnthropicProvider(BaseProvider[Anthropic]):
@@ -38,6 +55,8 @@ class AnthropicProvider(BaseProvider[Anthropic]):
 
     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
@@ -45,6 +64,11 @@ class AnthropicProvider(BaseProvider[Anthropic]):
         """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,
@@ -55,32 +79,27 @@ class AnthropicProvider(BaseProvider[Anthropic]):
         format: type[FormattableT] | Format[FormattableT] | None = None,
         **params: Unpack[Params],
     ) -> Response | Response[FormattableT]:
-        """Generate an `llm.Response` by synchronously calling the Anthropic Messages API.
-
-        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.
-        """
-        input_messages, format, kwargs = _utils.encode_request(
+        """Generate an `llm.Response` by synchronously calling the Anthropic Messages API."""
+        if _should_use_beta(model_id, format):
+            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)
-
-        assistant_message, finish_reason = _utils.decode_response(
+        assistant_message, finish_reason, usage = _utils.decode_response(
             anthropic_response, model_id
         )
-
         return Response(
             raw=anthropic_response,
             provider_id="anthropic",
@@ -91,7 +110,8 @@ class AnthropicProvider(BaseProvider[Anthropic]):
             input_messages=input_messages,
             assistant_message=assistant_message,
             finish_reason=finish_reason,
-            format=format,
+            usage=usage,
+            format=resolved_format,
         )
 
     def _context_call(
@@ -106,33 +126,28 @@ class AnthropicProvider(BaseProvider[Anthropic]):
         format: type[FormattableT] | Format[FormattableT] | None = None,
         **params: Unpack[Params],
     ) -> ContextResponse[DepsT, None] | ContextResponse[DepsT, FormattableT]:
-        """Generate an `llm.ContextResponse` by synchronously calling the Anthropic Messages API.
-
-        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.
-        """
-        input_messages, format, kwargs = _utils.encode_request(
+        """Generate an `llm.ContextResponse` by synchronously calling the Anthropic Messages API."""
+        if _should_use_beta(model_id, format):
+            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)
-
-        assistant_message, finish_reason = _utils.decode_response(
+        assistant_message, finish_reason, usage = _utils.decode_response(
             anthropic_response, model_id
         )
-
         return ContextResponse(
             raw=anthropic_response,
             provider_id="anthropic",
@@ -143,7 +158,8 @@ class AnthropicProvider(BaseProvider[Anthropic]):
             input_messages=input_messages,
             assistant_message=assistant_message,
             finish_reason=finish_reason,
-            format=format,
+            usage=usage,
+            format=resolved_format,
         )
 
     async def _call_async(
@@ -155,32 +171,27 @@ class AnthropicProvider(BaseProvider[Anthropic]):
         format: type[FormattableT] | Format[FormattableT] | None = None,
         **params: Unpack[Params],
     ) -> AsyncResponse | AsyncResponse[FormattableT]:
-        """Generate an `llm.AsyncResponse` by asynchronously calling the Anthropic Messages API.
-
-        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.
-        """
-        input_messages, format, kwargs = _utils.encode_request(
+        """Generate an `llm.AsyncResponse` by asynchronously calling the Anthropic Messages API."""
+        if _should_use_beta(model_id, format):
+            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)
-
-        assistant_message, finish_reason = _utils.decode_response(
+        assistant_message, finish_reason, usage = _utils.decode_response(
             anthropic_response, model_id
         )
-
         return AsyncResponse(
             raw=anthropic_response,
             provider_id="anthropic",
@@ -191,7 +202,8 @@ class AnthropicProvider(BaseProvider[Anthropic]):
             input_messages=input_messages,
             assistant_message=assistant_message,
             finish_reason=finish_reason,
-            format=format,
+            usage=usage,
+            format=resolved_format,
         )
 
     async def _context_call_async(
@@ -206,33 +218,28 @@ class AnthropicProvider(BaseProvider[Anthropic]):
         format: type[FormattableT] | Format[FormattableT] | None = None,
         **params: Unpack[Params],
     ) -> AsyncContextResponse[DepsT, None] | AsyncContextResponse[DepsT, FormattableT]:
-        """Generate an `llm.AsyncContextResponse` by asynchronously calling the Anthropic Messages API.
-
-        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.
-        """
-        input_messages, format, kwargs = _utils.encode_request(
+        """Generate an `llm.AsyncContextResponse` by asynchronously calling the Anthropic Messages API."""
+        if _should_use_beta(model_id, format):
+            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)
-
-        assistant_message, finish_reason = _utils.decode_response(
+        assistant_message, finish_reason, usage = _utils.decode_response(
             anthropic_response, model_id
         )
-
         return AsyncContextResponse(
             raw=anthropic_response,
             provider_id="anthropic",
@@ -243,7 +250,8 @@ class AnthropicProvider(BaseProvider[Anthropic]):
             input_messages=input_messages,
             assistant_message=assistant_message,
             finish_reason=finish_reason,
-            format=format,
+            usage=usage,
+            format=resolved_format,
         )
 
     def _stream(
@@ -255,30 +263,25 @@ class AnthropicProvider(BaseProvider[Anthropic]):
         format: type[FormattableT] | Format[FormattableT] | None = None,
         **params: Unpack[Params],
     ) -> StreamResponse | StreamResponse[FormattableT]:
-        """Generate an `llm.StreamResponse` by synchronously streaming from the Anthropic Messages API.
-
-        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.
-        """
-        input_messages, format, kwargs = _utils.encode_request(
+        """Generate an `llm.StreamResponse` by synchronously streaming from the Anthropic Messages API."""
+        if _should_use_beta(model_id, format):
+            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)
-
         chunk_iterator = _utils.decode_stream(anthropic_stream)
-
         return StreamResponse(
             provider_id="anthropic",
             model_id=model_id,
@@ -287,7 +290,7 @@ class AnthropicProvider(BaseProvider[Anthropic]):
             tools=tools,
             input_messages=input_messages,
             chunk_iterator=chunk_iterator,
-            format=format,
+            format=resolved_format,
         )
 
     def _context_stream(
@@ -302,31 +305,26 @@ class AnthropicProvider(BaseProvider[Anthropic]):
         format: type[FormattableT] | Format[FormattableT] | None = None,
         **params: Unpack[Params],
     ) -> ContextStreamResponse[DepsT] | ContextStreamResponse[DepsT, FormattableT]:
-        """Generate an `llm.ContextStreamResponse` by synchronously streaming from the Anthropic Messages API.
-
-        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.
-        """
-        input_messages, format, kwargs = _utils.encode_request(
+        """Generate an `llm.ContextStreamResponse` by synchronously streaming from the Anthropic Messages API."""
+        if _should_use_beta(model_id, format):
+            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)
-
         chunk_iterator = _utils.decode_stream(anthropic_stream)
-
         return ContextStreamResponse(
             provider_id="anthropic",
             model_id=model_id,
@@ -335,7 +333,7 @@ class AnthropicProvider(BaseProvider[Anthropic]):
             tools=tools,
             input_messages=input_messages,
             chunk_iterator=chunk_iterator,
-            format=format,
+            format=resolved_format,
         )
 
     async def _stream_async(
@@ -347,30 +345,24 @@ class AnthropicProvider(BaseProvider[Anthropic]):
         format: type[FormattableT] | Format[FormattableT] | None = None,
         **params: Unpack[Params],
     ) -> AsyncStreamResponse | AsyncStreamResponse[FormattableT]:
-        """Generate an `llm.AsyncStreamResponse` by asynchronously streaming from the Anthropic Messages API.
-
-        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.
-        """
-        input_messages, format, kwargs = _utils.encode_request(
+        """Generate an `llm.AsyncStreamResponse` by asynchronously streaming from the Anthropic Messages API."""
+        if _should_use_beta(model_id, format):
+            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)
-
         chunk_iterator = _utils.decode_async_stream(anthropic_stream)
-
         return AsyncStreamResponse(
             provider_id="anthropic",
             model_id=model_id,
@@ -379,7 +371,7 @@ class AnthropicProvider(BaseProvider[Anthropic]):
             tools=tools,
             input_messages=input_messages,
             chunk_iterator=chunk_iterator,
-            format=format,
+            format=resolved_format,
         )
 
     async def _context_stream_async(
@@ -397,31 +389,26 @@ class AnthropicProvider(BaseProvider[Anthropic]):
         AsyncContextStreamResponse[DepsT]
         | AsyncContextStreamResponse[DepsT, FormattableT]
     ):
-        """Generate an `llm.AsyncContextStreamResponse` by asynchronously streaming from the Anthropic Messages API.
-
-        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.
-        """
-        input_messages, format, kwargs = _utils.encode_request(
+        """Generate an `llm.AsyncContextStreamResponse` by asynchronously streaming from the Anthropic Messages API."""
+        if _should_use_beta(model_id, format):
+            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)
-
         chunk_iterator = _utils.decode_async_stream(anthropic_stream)
-
         return AsyncContextStreamResponse(
             provider_id="anthropic",
             model_id=model_id,
@@ -430,5 +417,5 @@ class AnthropicProvider(BaseProvider[Anthropic]):
             tools=tools,
             input_messages=input_messages,
             chunk_iterator=chunk_iterator,
-            format=format,
+            format=resolved_format,
         )

mirascope/llm/providers/base/__init__.py

@@ -1,7 +1,7 @@
 """Base client interfaces and types."""
 
 from . import _utils
-from .base_provider import BaseProvider, Provider
+from .base_provider import BaseProvider, Provider, ProviderErrorMap
 from .kwargs import BaseKwargs, KwargsT
 from .params import Params
 
@@ -11,5 +11,6 @@ __all__ = [
     "KwargsT",
     "Params",
     "Provider",
+    "ProviderErrorMap",
     "_utils",
 ]

mirascope/llm/providers/base/_utils.py

@@ -1,7 +1,7 @@
 import logging
 from collections.abc import Generator, Sequence
 from contextlib import contextmanager
-from typing import TYPE_CHECKING, TypeAlias, get_type_hints
+from typing import TYPE_CHECKING, TypeAlias, cast, get_type_hints
 
 from ...content import Text
 from ...messages import AssistantMessage, Message, SystemMessage, UserMessage
@@ -16,6 +16,20 @@ logger = logging.getLogger(__name__)
 SystemMessageContent: TypeAlias = str | None
 
 
+def ensure_additional_properties_false(obj: object) -> None:
+    """Recursively adds additionalProperties = False to a schema, required for strict mode."""
+    if isinstance(obj, dict):
+        obj = cast(dict[str, object], obj)
+        if obj.get("type") == "object" and "additionalProperties" not in obj:
+            obj["additionalProperties"] = False
+        for value in obj.values():
+            ensure_additional_properties_false(value)
+    elif isinstance(obj, list):
+        obj = cast(list[object], obj)
+        for item in obj:
+            ensure_additional_properties_false(item)
+
+
 def add_system_instructions(
     messages: Sequence[Message], additional_system_instructions: str
 ) -> Sequence[Message]: