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

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

@@ -21,7 +21,6 @@ from ....exceptions import FormattingModeNotSupportedError
 from ....formatting import (
     Format,
     FormattableT,
-    _utils as _formatting_utils,
     resolve_format,
 )
 from ....messages import AssistantMessage, Message, UserMessage
@@ -60,11 +59,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 +72,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 +80,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 +88,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 +97,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 +110,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,7 +126,7 @@ 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
 
@@ -146,7 +147,7 @@ def beta_encode_request(
     """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(
@@ -174,7 +175,7 @@ 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)
+            format_tool_schema = format.create_tool_schema()
             anthropic_tools.append(_beta_convert_tool_to_tool_param(format_tool_schema))
             if tools:
                 kwargs["tool_choice"] = {"type": "any"}
@@ -201,7 +202,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

@@ -180,7 +180,9 @@ 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(
@@ -217,7 +219,7 @@ class _AnthropicChunkProcessor:
                     if self.accumulated_tool_json
                     else {}
                 )
-                yield ToolCallEndChunk()
+                yield ToolCallEndChunk(id=self.current_block_param["id"])
             elif block_type == "thinking":
                 yield ThoughtEndChunk()
             else:

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

@@ -13,18 +13,26 @@ from ....exceptions import FeatureNotSupportedError, FormattingModeNotSupportedE
 from ....formatting import (
     Format,
     FormattableT,
-    _utils as _formatting_utils,
     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 Params, ThinkingLevel, _utils as _base_utils
 from ..model_id import AnthropicModelId, model_name
 
 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 +45,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 +78,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 +88,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 +105,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
 
@@ -254,7 +295,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 +311,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
 
@@ -298,7 +339,7 @@ def encode_request(
     """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(
@@ -316,7 +357,7 @@ def encode_request(
                 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 +383,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

@@ -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 (
+    APIError,
+    AuthenticationError,
+    BadRequestError,
+    ConnectionError,
+    NotFoundError,
+    PermissionError,
+    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: APIError,  # Catch-all for unknown Anthropic errors
+}

mirascope/llm/providers/anthropic/beta_provider.py

@@ -29,6 +29,7 @@ from ...tools import (
     Toolkit,
 )
 from ..base import BaseProvider, Params
+from . import _utils
 from ._utils import beta_decode, beta_encode
 from .model_id import model_name
 
@@ -38,6 +39,7 @@ class AnthropicBetaProvider(BaseProvider[Anthropic]):
 
     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
@@ -46,6 +48,10 @@ class AnthropicBetaProvider(BaseProvider[Anthropic]):
         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,
         *,

mirascope/llm/providers/anthropic/provider.py

@@ -55,6 +55,7 @@ class AnthropicProvider(BaseProvider[Anthropic]):
 
     id = "anthropic"
     default_scope = "anthropic/"
+    error_map = _utils.ANTHROPIC_ERROR_MAP
     _beta_provider: AnthropicBetaProvider
 
     def __init__(
@@ -65,6 +66,10 @@ class AnthropicProvider(BaseProvider[Anthropic]):
         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,
         *,

mirascope/llm/providers/base/__init__.py

@@ -1,9 +1,9 @@
 """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
+from .params import Params, ThinkingConfig, ThinkingLevel
 
 __all__ = [
     "BaseKwargs",
@@ -11,5 +11,8 @@ __all__ = [
     "KwargsT",
     "Params",
     "Provider",
+    "ProviderErrorMap",
+    "ThinkingConfig",
+    "ThinkingLevel",
     "_utils",
 ]

mirascope/llm/providers/base/_utils.py

@@ -10,6 +10,7 @@ from .params import Params
 
 if TYPE_CHECKING:
     from ..model_id import ModelId
+    from .params import ThinkingConfig
 
 logger = logging.getLogger(__name__)
 
@@ -138,17 +139,11 @@ class SafeParamsAccessor:
         return self._params.get("stop_sequences")
 
     @property
-    def thinking(self) -> bool | None:
+    def thinking(self) -> "ThinkingConfig | None":
         """Access the thinking parameter."""
         self._unaccessed.discard("thinking")
         return self._params.get("thinking")
 
-    @property
-    def encode_thoughts_as_text(self) -> bool | None:
-        """Access the encode_thoughts_as_text parameter."""
-        self._unaccessed.discard("encode_thoughts_as_text")
-        return self._params.get("encode_thoughts_as_text")
-
     def emit_warning_for_unused_param(
         self,
         param_name: str,