mirascope 2.0.0a2__py3-none-any.whl → 2.0.0a4__py3-none-any.whl

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)."""

mirascope/llm/providers/anthropic/provider.py

@@ -0,0 +1,416 @@
+"""Anthropic client implementation."""
+
+from collections.abc import Sequence
+from typing_extensions import Unpack
+
+from anthropic import Anthropic, AsyncAnthropic
+
+from ...context import Context, DepsT
+from ...formatting import Format, FormattableT, resolve_format
+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, 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]):
+    """The client for the Anthropic LLM model."""
+
+    id = "anthropic"
+    default_scope = "anthropic/"
+    _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 _call(
+        self,
+        *,
+        model_id: AnthropicModelId,
+        messages: Sequence[Message],
+        tools: Sequence[Tool] | Toolkit | None = None,
+        format: type[FormattableT] | Format[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):
+            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, usage = _utils.decode_response(
+            anthropic_response, model_id
+        )
+        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] | 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):
+            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, usage = _utils.decode_response(
+            anthropic_response, model_id
+        )
+        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] | 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):
+            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, usage = _utils.decode_response(
+            anthropic_response, model_id
+        )
+        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] | 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):
+            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, usage = _utils.decode_response(
+            anthropic_response, model_id
+        )
+        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] | 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):
+            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,
+            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] | 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):
+            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,
+            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] | 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):
+            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,
+            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] | 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):
+            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,
+            provider_model_name=model_name(model_id),
+            params=params,
+            tools=tools,
+            input_messages=input_messages,
+            chunk_iterator=chunk_iterator,
+            format=resolved_format,
+        )

mirascope/llm/{clients → providers}/base/__init__.py

@@ -1,15 +1,15 @@
 """Base client interfaces and types."""
 
 from . import _utils
-from .client import BaseClient, ClientT
+from .base_provider import BaseProvider, Provider
 from .kwargs import BaseKwargs, KwargsT
 from .params import Params
 
 __all__ = [
-    "BaseClient",
     "BaseKwargs",
-    "ClientT",
+    "BaseProvider",
     "KwargsT",
     "Params",
+    "Provider",
     "_utils",
 ]

mirascope/llm/{clients → providers}/base/_utils.py

@@ -1,20 +1,35 @@
 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
+from ..provider_id import ProviderId
 from .params import Params
 
 if TYPE_CHECKING:
-    from ..providers import ModelId, Provider
+    from ..model_id import ModelId
 
 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]:
@@ -61,8 +76,8 @@ def extract_system_message(
     This is intended for use in clients where the system message is not included in the
     input messages, but passed as an additional argument or metadata.
     """
-    system_message_content = None
-    remaining_messages = []
+    system_message_content: SystemMessageContent = None
+    remaining_messages: list[UserMessage | AssistantMessage] = []
 
     for i, message in enumerate(messages):
         if message.role == "system":
@@ -138,10 +153,10 @@ class SafeParamsAccessor:
         self,
         param_name: str,
         param_value: object,
-        provider: "Provider",
+        provider_id: "ProviderId",
         model_id: "ModelId | None" = None,
     ) -> None:
-        unsupported_by = f"provider: {provider}"
+        unsupported_by = f"provider: {provider_id}"
         if model_id:
             unsupported_by += f" with model_id: {model_id}"
         logger.warning(
@@ -159,7 +174,7 @@ class SafeParamsAccessor:
 def ensure_all_params_accessed(
     *,
     params: Params,
-    provider: "Provider",
+    provider_id: "ProviderId",
     unsupported_params: list[str] | None = None,
 ) -> Generator[SafeParamsAccessor, None, None]:
     """Context manager that ensures all parameters are accessed.
@@ -185,7 +200,9 @@ def ensure_all_params_accessed(
     unsupported_params = unsupported_params or []
     for unsupported in unsupported_params:
         if (val := params.get(unsupported)) is not None:
-            accessor.emit_warning_for_unused_param(unsupported, val, provider=provider)
+            accessor.emit_warning_for_unused_param(
+                unsupported, val, provider_id=provider_id
+            )
     try:
         yield accessor
     finally: