mirascope 2.0.0a5__py3-none-any.whl → 2.0.1__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,26 +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,
-    _utils as _formatting_utils,
+    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"
 
 
@@ -60,11 +62,11 @@ class BetaParseKwargs(TypedDict, total=False):
 
 def _beta_encode_content(
     content: Sequence[ContentPart],
-    encode_thoughts: bool,
+    encode_thoughts_as_text: bool,
     add_cache_control: bool = False,
 ) -> str | Sequence[BetaContentBlockParam]:
     """Convert mirascope content to Beta Anthropic content format."""
-    result = encode_content(content, encode_thoughts, add_cache_control)
+    result = encode_content(content, encode_thoughts_as_text, add_cache_control)
     if isinstance(result, str):
         return result
     return cast(Sequence[BetaContentBlockParam], result)
@@ -73,7 +75,7 @@ def _beta_encode_content(
 def _beta_encode_message(
     message: UserMessage | AssistantMessage,
     model_id: str,
-    encode_thoughts: bool,
+    encode_thoughts_as_text: bool,
     add_cache_control: bool = False,
 ) -> BetaMessageParam:
     """Convert user or assistant Message to Beta MessageParam format.
@@ -81,7 +83,7 @@ def _beta_encode_message(
     Args:
         message: The message to encode
         model_id: The Anthropic model ID
-        encode_thoughts: Whether to encode thought blocks as text
+        encode_thoughts_as_text: Whether to encode thought blocks as text
         add_cache_control: Whether to add cache_control to the last content block
     """
     if (
@@ -89,7 +91,7 @@ def _beta_encode_message(
         and message.provider_id == "anthropic"
         and message.model_id == model_id
         and message.raw_message
-        and not encode_thoughts
+        and not encode_thoughts_as_text
         and not add_cache_control
     ):
         raw = cast(dict[str, Any], message.raw_message)
@@ -98,7 +100,9 @@ def _beta_encode_message(
             content=raw["content"],
         )
 
-    content = _beta_encode_content(message.content, encode_thoughts, add_cache_control)
+    content = _beta_encode_content(
+        message.content, encode_thoughts_as_text, add_cache_control
+    )
 
     return BetaMessageParam(
         role=message.role,
@@ -109,7 +113,7 @@ def _beta_encode_message(
 def _beta_encode_messages(
     messages: Sequence[UserMessage | AssistantMessage],
     model_id: str,
-    encode_thoughts: bool,
+    encode_thoughts_as_text: bool,
 ) -> Sequence[BetaMessageParam]:
     """Encode messages and add cache control for multi-turn conversations.
 
@@ -125,14 +129,34 @@ def _beta_encode_messages(
         is_last = i == len(messages) - 1
         add_cache = has_assistant_message and is_last
         encoded_messages.append(
-            _beta_encode_message(message, model_id, encode_thoughts, add_cache)
+            _beta_encode_message(message, model_id, encode_thoughts_as_text, add_cache)
         )
     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(
@@ -140,13 +164,16 @@ 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."""
 
     processed = process_params(params, DEFAULT_MAX_TOKENS)
-    encode_thoughts = processed.pop("encode_thoughts", False)
+    encode_thoughts_as_text = processed.pop("encode_thoughts_as_text", False)
     max_tokens = processed.pop("max_tokens", DEFAULT_MAX_TOKENS)
 
     kwargs: BetaParseKwargs = BetaParseKwargs(
@@ -159,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,
                 )
@@ -174,8 +220,12 @@ def beta_encode_request(
                 kwargs["output_format"] = cast(type[BaseModel], format.formattable)
 
         if format.mode == "tool":
-            format_tool_schema = _formatting_utils.create_tool_schema(format)
-            anthropic_tools.append(_beta_convert_tool_to_tool_param(format_tool_schema))
+            format_tool_schema = format.create_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:
@@ -201,7 +251,7 @@ def beta_encode_request(
     )
 
     kwargs["messages"] = _beta_encode_messages(
-        remaining_messages, model_id, encode_thoughts
+        remaining_messages, model_id, encode_thoughts_as_text
     )
 
     if system_message_content:

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",
@@ -180,14 +187,17 @@ class _AnthropicChunkProcessor:
                         f"Received input_json_delta for {self.current_block_param['type']} block"
                     )
                 self.accumulated_tool_json += delta.partial_json
-                yield ToolCallChunk(delta=delta.partial_json)
+                yield ToolCallChunk(
+                    id=self.current_block_param["id"], delta=delta.partial_json
+                )
             elif delta.type == "thinking_delta":
                 if self.current_block_param["type"] != "thinking":  # pragma: no cover
                     raise RuntimeError(
                         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(
@@ -217,9 +227,10 @@ class _AnthropicChunkProcessor:
                     if self.accumulated_tool_json
                     else {}
                 )
-                yield ToolCallEndChunk()
+                yield ToolCallEndChunk(id=self.current_block_param["id"])
             elif block_type == "thinking":
-                yield ThoughtEndChunk()
+                if self.include_thoughts:
+                    yield ThoughtEndChunk()
             else:
                 raise NotImplementedError
 
@@ -255,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)
@@ -266,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,30 +1,44 @@
 """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,
-    _utils as _formatting_utils,
+    OutputParser,
     resolve_format,
 )
 from ....messages import AssistantMessage, Message, UserMessage
 from ....tools import FORMAT_TOOL_NAME, AnyToolSchema, BaseToolkit
-from ...base import Params, _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"
 
+# Thinking level to a float multiplier % of max tokens
+THINKING_LEVEL_TO_BUDGET_MULTIPLIER: dict[ThinkingLevel, float] = {
+    "minimal": 0,  # Will become 1024 (actual minimal value)
+    "low": 0.2,
+    "medium": 0.4,
+    "high": 0.6,
+    "max": 0.8,
+}
+
 AnthropicImageMimeType = Literal["image/jpeg", "image/png", "image/gif", "image/webp"]
 
 
@@ -37,6 +51,30 @@ def encode_image_mime_type(mime_type: ImageMimeType) -> AnthropicImageMimeType:
     )  # pragma: no cover
 
 
+def compute_thinking_budget(
+    level: ThinkingLevel,
+    max_tokens: int,
+) -> int:
+    """Compute Anthropic token budget from ThinkingConfig level.
+
+    Args:
+        level: The thinking level from ThinkingConfig
+        max_tokens: The max_tokens value for the request
+
+    Returns:
+        Token budget for thinking (0 to disable, positive for budget)
+    """
+
+    if level == "none":
+        return 0
+    elif level == "default":
+        return -1  # Do not set thinking, leave to provider default
+
+    multiplier: float = THINKING_LEVEL_TO_BUDGET_MULTIPLIER.get(level, 0.4)
+    budget = int(multiplier * max_tokens)
+    return max(1024, budget)  # Always return at least 1024, minimum allowed budget
+
+
 class ProcessedParams(TypedDict, total=False):
     """Common parameters processed from Params."""
 
@@ -46,7 +84,7 @@ class ProcessedParams(TypedDict, total=False):
     top_k: int
     stop_sequences: list[str]
     thinking: dict[str, Any]
-    encode_thoughts: bool
+    encode_thoughts_as_text: bool
 
 
 def process_params(params: Params, default_max_tokens: int) -> ProcessedParams:
@@ -56,7 +94,7 @@ def process_params(params: Params, default_max_tokens: int) -> ProcessedParams:
     """
     result: ProcessedParams = {
         "max_tokens": default_max_tokens,
-        "encode_thoughts": False,
+        "encode_thoughts_as_text": False,
     }
 
     with _base_utils.ensure_all_params_accessed(
@@ -73,13 +111,22 @@ def process_params(params: Params, default_max_tokens: int) -> ProcessedParams:
         if param_accessor.stop_sequences is not None:
             result["stop_sequences"] = param_accessor.stop_sequences
         if param_accessor.thinking is not None:
-            if param_accessor.thinking:
-                budget_tokens = max(1024, result["max_tokens"] // 2)
+            thinking_config = param_accessor.thinking
+            level = thinking_config.get("level")
+
+            # Compute token budget from level
+            budget_tokens = compute_thinking_budget(level, result["max_tokens"])
+            if budget_tokens == 0:
+                result["thinking"] = {"type": "disabled"}
+            elif budget_tokens > 0:
                 result["thinking"] = {"type": "enabled", "budget_tokens": budget_tokens}
             else:
-                result["thinking"] = {"type": "disabled"}
-        if param_accessor.encode_thoughts_as_text:
-            result["encode_thoughts"] = True
+                # budget is -1, do not set thinking at all.
+                pass
+
+            # Handle encode_thoughts_as_text from ThinkingConfig
+            if thinking_config.get("encode_thoughts_as_text"):
+                result["encode_thoughts_as_text"] = True
 
     return result
 
@@ -185,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,
                 )
             )
@@ -254,7 +301,7 @@ def _encode_message(
 def _encode_messages(
     messages: Sequence[UserMessage | AssistantMessage],
     model_id: AnthropicModelId,
-    encode_thoughts: bool,
+    encode_thoughts_as_text: bool,
 ) -> Sequence[anthropic_types.MessageParam]:
     """Encode messages and add cache control for multi-turn conversations.
 
@@ -270,7 +317,7 @@ def _encode_messages(
         is_last = i == len(messages) - 1
         add_cache = has_assistant_message and is_last
         encoded_messages.append(
-            _encode_message(message, model_id, encode_thoughts, add_cache)
+            _encode_message(message, model_id, encode_thoughts_as_text, add_cache)
         )
     return encoded_messages
 
@@ -292,13 +339,16 @@ 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."""
 
     processed = process_params(params, DEFAULT_MAX_TOKENS)
-    encode_thoughts = processed.pop("encode_thoughts", False)
+    encode_thoughts_as_text = processed.pop("encode_thoughts_as_text", False)
     max_tokens = processed.pop("max_tokens", DEFAULT_MAX_TOKENS)
 
     kwargs: MessageCreateKwargs = MessageCreateKwargs(
@@ -306,17 +356,27 @@ 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,
             )
         if format.mode == "tool":
-            format_tool_schema = _formatting_utils.create_tool_schema(format)
+            format_tool_schema = format.create_tool_schema()
             anthropic_tools.append(convert_tool_to_tool_param(format_tool_schema))
             if tools:
                 kwargs["tool_choice"] = {"type": "any"}
@@ -342,7 +402,9 @@ def encode_request(
         messages
     )
 
-    kwargs["messages"] = _encode_messages(remaining_messages, model_id, encode_thoughts)
+    kwargs["messages"] = _encode_messages(
+        remaining_messages, model_id, encode_thoughts_as_text
+    )
 
     if system_message_content:
         kwargs["system"] = [

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
 }