mirascope 2.0.0a6__py3-none-any.whl → 2.0.2__py3-none-any.whl

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

@@ -1,7 +1,7 @@
 """Beta Anthropic message encoding and request preparation."""
 
 from collections.abc import Sequence
-from typing import Any, TypedDict, cast
+from typing import TYPE_CHECKING, Any, TypedDict, cast
 from typing_extensions import Required
 
 from anthropic import Omit
@@ -17,25 +17,28 @@ from anthropic.types.beta import (
 from pydantic import BaseModel
 
 from ....content import ContentPart
-from ....exceptions import FormattingModeNotSupportedError
+from ....exceptions import FeatureNotSupportedError
 from ....formatting import (
     Format,
     FormattableT,
+    OutputParser,
     resolve_format,
 )
 from ....messages import AssistantMessage, Message, UserMessage
 from ....tools import AnyToolSchema, BaseToolkit
-from ...base import Params, _utils as _base_utils
+from ...base import _utils as _base_utils
 from ..model_id import model_name
 from ..model_info import MODELS_WITHOUT_STRICT_STRUCTURED_OUTPUTS
 from .encode import (
     DEFAULT_MAX_TOKENS,
     FORMAT_TOOL_NAME,
-    convert_tool_to_tool_param,
     encode_content,
     process_params,
 )
 
+if TYPE_CHECKING:
+    from ....models import Params
+
 DEFAULT_FORMAT_MODE = "strict"
 
 
@@ -131,9 +134,29 @@ def _beta_encode_messages(
     return encoded_messages
 
 
-def _beta_convert_tool_to_tool_param(tool: AnyToolSchema) -> BetaToolParam:
-    """Convert a single Mirascope tool to Beta Anthropic tool format."""
-    return cast(BetaToolParam, convert_tool_to_tool_param(tool))
+def _beta_convert_tool_to_tool_param(
+    tool: AnyToolSchema, model_supports_strict: bool
+) -> BetaToolParam:
+    """Convert a single Mirascope tool to Beta Anthropic tool format.
+
+    If the tool has strict=True (or None, and the model supports strict), the schema
+    is modified to be compatible with Anthropic's strict structured outputs beta
+    by adding additionalProperties: false to all object schemas, and strict=True
+    is passed to the API.
+    """
+    schema_dict = tool.parameters.model_dump(by_alias=True, exclude_none=True)
+    schema_dict["type"] = "object"
+
+    strict = model_supports_strict if tool.strict is None else tool.strict
+    if strict:
+        _base_utils.ensure_additional_properties_false(schema_dict)
+
+    return BetaToolParam(
+        name=tool.name,
+        description=tool.description,
+        input_schema=schema_dict,
+        strict=strict,
+    )
 
 
 def beta_encode_request(
@@ -141,8 +164,11 @@ def beta_encode_request(
     model_id: str,
     messages: Sequence[Message],
     tools: Sequence[AnyToolSchema] | BaseToolkit[AnyToolSchema] | None,
-    format: type[FormattableT] | Format[FormattableT] | None,
-    params: Params,
+    format: type[FormattableT]
+    | Format[FormattableT]
+    | OutputParser[FormattableT]
+    | None,
+    params: "Params",
 ) -> tuple[Sequence[Message], Format[FormattableT] | None, BetaParseKwargs]:
     """Prepares a request for the Anthropic beta.messages.parse method."""
 
@@ -160,14 +186,33 @@ def beta_encode_request(
     )
 
     tools = tools.tools if isinstance(tools, BaseToolkit) else tools or []
-    anthropic_tools = [_beta_convert_tool_to_tool_param(tool) for tool in tools]
+
+    model_supports_strict = (
+        model_name(model_id) not in MODELS_WITHOUT_STRICT_STRUCTURED_OUTPUTS
+    )
+    # Check for strict tools on models that don't support them
+    if _base_utils.has_strict_tools(tools) and not model_supports_strict:
+        raise FeatureNotSupportedError(
+            feature="strict tools",
+            provider_id="anthropic",
+            model_id=model_id,
+            message="Strict tools require a model that supports structured outputs. "
+            "Use a newer model like claude-sonnet-4-5 or set strict=False on your tools.",
+        )
+
+    anthropic_tools = [
+        _beta_convert_tool_to_tool_param(
+            tool, model_supports_strict=model_supports_strict
+        )
+        for tool in tools
+    ]
     format = resolve_format(format, default_mode=DEFAULT_FORMAT_MODE)
 
     if format is not None:
         if format.mode == "strict":
             if model_name(model_id) in MODELS_WITHOUT_STRICT_STRUCTURED_OUTPUTS:
-                raise FormattingModeNotSupportedError(
-                    formatting_mode=format.mode,
+                raise FeatureNotSupportedError(
+                    feature=f"formatting_mode:{format.mode}",
                     provider_id="anthropic",
                     model_id=model_id,
                 )
@@ -176,7 +221,11 @@ def beta_encode_request(
 
         if format.mode == "tool":
             format_tool_schema = format.create_tool_schema()
-            anthropic_tools.append(_beta_convert_tool_to_tool_param(format_tool_schema))
+            anthropic_tools.append(
+                _beta_convert_tool_to_tool_param(
+                    format_tool_schema, model_supports_strict=model_supports_strict
+                )
+            )
             if tools:
                 kwargs["tool_choice"] = {"type": "any"}
             else:

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

@@ -83,10 +83,15 @@ def decode_usage(
 def decode_response(
     response: anthropic_types.Message,
     model_id: AnthropicModelId,
+    *,
+    include_thoughts: bool,
 ) -> tuple[AssistantMessage, FinishReason | None, Usage]:
     """Convert Anthropic message to mirascope AssistantMessage and usage."""
+    content = [_decode_assistant_content(part) for part in response.content]
+    if not include_thoughts:
+        content = [part for part in content if part.type != "thought"]
     assistant_message = AssistantMessage(
-        content=[_decode_assistant_content(part) for part in response.content],
+        content=content,
         provider_id="anthropic",
         model_id=model_id,
         provider_model_name=model_name(model_id),
@@ -115,10 +120,11 @@ ContentBlock: TypeAlias = (
 class _AnthropicChunkProcessor:
     """Processes Anthropic stream events and maintains state across events."""
 
-    def __init__(self) -> None:
+    def __init__(self, *, include_thoughts: bool) -> None:
         self.current_block_param: ContentBlock | None = None
         self.accumulated_tool_json: str = ""
         self.accumulated_blocks: list[ContentBlock] = []
+        self.include_thoughts = include_thoughts
 
     def process_event(
         self, event: anthropic_types.RawMessageStreamEvent
@@ -153,7 +159,8 @@ class _AnthropicChunkProcessor:
                     "thinking": "",
                     "signature": "",
                 }
-                yield ThoughtStartChunk()
+                if self.include_thoughts:
+                    yield ThoughtStartChunk()
             elif content_block.type == "redacted_thinking":  # pragma: no cover
                 self.current_block_param = {
                     "type": "redacted_thinking",
@@ -189,7 +196,8 @@ class _AnthropicChunkProcessor:
                         f"Received thinking_delta for {self.current_block_param['type']} block"
                     )
                 self.current_block_param["thinking"] += delta.thinking
-                yield ThoughtChunk(delta=delta.thinking)
+                if self.include_thoughts:
+                    yield ThoughtChunk(delta=delta.thinking)
             elif delta.type == "signature_delta":
                 if self.current_block_param["type"] != "thinking":  # pragma: no cover
                     raise RuntimeError(
@@ -221,7 +229,8 @@ class _AnthropicChunkProcessor:
                 )
                 yield ToolCallEndChunk(id=self.current_block_param["id"])
             elif block_type == "thinking":
-                yield ThoughtEndChunk()
+                if self.include_thoughts:
+                    yield ThoughtEndChunk()
             else:
                 raise NotImplementedError
 
@@ -257,10 +266,10 @@ class _AnthropicChunkProcessor:
 
 
 def decode_stream(
-    anthropic_stream_manager: MessageStreamManager,
+    anthropic_stream_manager: MessageStreamManager, *, include_thoughts: bool
 ) -> ChunkIterator:
     """Returns a ChunkIterator converted from an Anthropic MessageStreamManager."""
-    processor = _AnthropicChunkProcessor()
+    processor = _AnthropicChunkProcessor(include_thoughts=include_thoughts)
     with anthropic_stream_manager as stream:
         for event in stream._raw_stream:  # pyright: ignore[reportPrivateUsage]
             yield from processor.process_event(event)
@@ -268,10 +277,10 @@ def decode_stream(
 
 
 async def decode_async_stream(
-    anthropic_stream_manager: AsyncMessageStreamManager,
+    anthropic_stream_manager: AsyncMessageStreamManager, *, include_thoughts: bool
 ) -> AsyncChunkIterator:
     """Returns an AsyncChunkIterator converted from an Anthropic MessageStreamManager."""
-    processor = _AnthropicChunkProcessor()
+    processor = _AnthropicChunkProcessor(include_thoughts=include_thoughts)
     async with anthropic_stream_manager as stream:
         async for event in stream._raw_stream:  # pyright: ignore[reportPrivateUsage]
             for item in processor.process_event(event):

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

@@ -1,25 +1,31 @@
 """Shared Anthropic encoding utilities."""
 
+from __future__ import annotations
+
 import json
 from collections.abc import Sequence
 from functools import lru_cache
-from typing import Any, Literal, TypedDict, cast
+from typing import TYPE_CHECKING, Any, Literal, TypedDict, cast
 from typing_extensions import Required
 
 from anthropic import Omit, types as anthropic_types
 
 from ....content import ContentPart, ImageMimeType
-from ....exceptions import FeatureNotSupportedError, FormattingModeNotSupportedError
+from ....exceptions import FeatureNotSupportedError
 from ....formatting import (
     Format,
     FormattableT,
+    OutputParser,
     resolve_format,
 )
 from ....messages import AssistantMessage, Message, UserMessage
 from ....tools import FORMAT_TOOL_NAME, AnyToolSchema, BaseToolkit
-from ...base import Params, ThinkingLevel, _utils as _base_utils
+from ...base import _utils as _base_utils
 from ..model_id import AnthropicModelId, model_name
 
+if TYPE_CHECKING:
+    from ....models import Params, ThinkingLevel
+
 DEFAULT_MAX_TOKENS = 16000
 # TODO: Change DEFAULT_FORMAT_MODE to strict when strict is no longer a beta feature.
 DEFAULT_FORMAT_MODE = "tool"
@@ -226,7 +232,7 @@ def encode_content(
                 anthropic_types.ToolResultBlockParam(
                     type="tool_result",
                     tool_use_id=part.id,
-                    content=str(part.value),
+                    content=str(part.result),
                     cache_control={"type": "ephemeral"} if should_add_cache else None,
                 )
             )
@@ -333,7 +339,10 @@ def encode_request(
     model_id: AnthropicModelId,
     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, MessageCreateKwargs]:
     """Prepares a request for the Anthropic messages.create method."""
@@ -347,12 +356,22 @@ def encode_request(
     )
 
     tools = tools.tools if isinstance(tools, BaseToolkit) else tools or []
+
+    # Check for strict tools - the non-beta API doesn't support them
+    if _base_utils.has_strict_tools(tools):
+        raise FeatureNotSupportedError(
+            feature="strict tools",
+            provider_id="anthropic",
+            model_id=model_id,
+            message="Anthropic provider does not support strict tools. Try the beta provider.",
+        )
+
     anthropic_tools = [convert_tool_to_tool_param(tool) for tool in tools]
     format = resolve_format(format, default_mode=DEFAULT_FORMAT_MODE)
     if format is not None:
         if format.mode == "strict":
-            raise FormattingModeNotSupportedError(
-                formatting_mode="strict",
+            raise FeatureNotSupportedError(
+                feature="formatting_mode:strict",
                 provider_id="anthropic",
                 model_id=model_id,
             )

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

@@ -16,12 +16,12 @@ from anthropic import (
 )
 
 from ....exceptions import (
-    APIError,
     AuthenticationError,
     BadRequestError,
     ConnectionError,
     NotFoundError,
     PermissionError,
+    ProviderError,
     RateLimitError,
     ResponseValidationError,
     ServerError,
@@ -42,5 +42,5 @@ ANTHROPIC_ERROR_MAP: ProviderErrorMap = {
     AnthropicAPITimeoutError: TimeoutError,
     AnthropicAPIConnectionError: ConnectionError,
     AnthropicAPIResponseValidationError: ResponseValidationError,
-    AnthropicError: APIError,  # Catch-all for unknown Anthropic errors
+    AnthropicError: ProviderError,  # Catch-all for unknown Anthropic errors
 }

mirascope/llm/providers/anthropic/beta_provider.py

@@ -1,12 +1,15 @@
 """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
+from ...formatting import Format, FormattableT, OutputParser
 from ...messages import Message
 from ...responses import (
     AsyncContextResponse,
@@ -28,11 +31,14 @@ from ...tools import (
     Tool,
     Toolkit,
 )
-from ..base import BaseProvider, Params
+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."""
@@ -58,7 +64,10 @@ class AnthropicBetaProvider(BaseProvider[Anthropic]):
         model_id: str,
         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 the beta Anthropic API."""
@@ -70,8 +79,9 @@ class AnthropicBetaProvider(BaseProvider[Anthropic]):
             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
+            beta_response, model_id, include_thoughts=include_thoughts
         )
         return Response(
             raw=beta_response,
@@ -96,7 +106,10 @@ class AnthropicBetaProvider(BaseProvider[Anthropic]):
         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 the beta Anthropic API."""
@@ -108,8 +121,9 @@ class AnthropicBetaProvider(BaseProvider[Anthropic]):
             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
+            beta_response, model_id, include_thoughts=include_thoughts
         )
         return ContextResponse(
             raw=beta_response,
@@ -131,7 +145,10 @@ class AnthropicBetaProvider(BaseProvider[Anthropic]):
         model_id: str,
         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 the beta Anthropic API."""
@@ -143,8 +160,9 @@ class AnthropicBetaProvider(BaseProvider[Anthropic]):
             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
+            beta_response, model_id, include_thoughts=include_thoughts
         )
         return AsyncResponse(
             raw=beta_response,
@@ -169,7 +187,10 @@ class AnthropicBetaProvider(BaseProvider[Anthropic]):
         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.AsyncContextResponse` using the beta Anthropic API."""
@@ -181,8 +202,9 @@ class AnthropicBetaProvider(BaseProvider[Anthropic]):
             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
+            beta_response, model_id, include_thoughts=include_thoughts
         )
         return AsyncContextResponse(
             raw=beta_response,
@@ -204,7 +226,10 @@ class AnthropicBetaProvider(BaseProvider[Anthropic]):
         model_id: str,
         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` using the beta Anthropic API."""
@@ -216,7 +241,10 @@ class AnthropicBetaProvider(BaseProvider[Anthropic]):
             params=params,
         )
         beta_stream = self.client.beta.messages.stream(**kwargs)
-        chunk_iterator = beta_decode.beta_decode_stream(beta_stream)
+        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,
@@ -237,7 +265,10 @@ class AnthropicBetaProvider(BaseProvider[Anthropic]):
         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` using the beta Anthropic API."""
@@ -249,7 +280,10 @@ class AnthropicBetaProvider(BaseProvider[Anthropic]):
             params=params,
         )
         beta_stream = self.client.beta.messages.stream(**kwargs)
-        chunk_iterator = beta_decode.beta_decode_stream(beta_stream)
+        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,
@@ -267,7 +301,10 @@ class AnthropicBetaProvider(BaseProvider[Anthropic]):
         model_id: str,
         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` using the beta Anthropic API."""
@@ -279,7 +316,10 @@ class AnthropicBetaProvider(BaseProvider[Anthropic]):
             params=params,
         )
         beta_stream = self.async_client.beta.messages.stream(**kwargs)
-        chunk_iterator = beta_decode.beta_decode_async_stream(beta_stream)
+        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,
@@ -300,7 +340,10 @@ class AnthropicBetaProvider(BaseProvider[Anthropic]):
         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]
@@ -315,7 +358,10 @@ class AnthropicBetaProvider(BaseProvider[Anthropic]):
             params=params,
         )
         beta_stream = self.async_client.beta.messages.stream(**kwargs)
-        chunk_iterator = beta_decode.beta_decode_async_stream(beta_stream)
+        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,