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

mirascope/llm/providers/anthropic/provider.py

@@ -1,12 +1,15 @@
 """Anthropic client 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, resolve_format
+from ...formatting import Format, FormattableT, OutputParser, resolve_format
 from ...messages import Message
 from ...responses import (
     AsyncContextResponse,
@@ -19,35 +22,50 @@ from ...responses import (
     StreamResponse,
 )
 from ...tools import (
+    AnyToolSchema,
     AsyncContextTool,
     AsyncContextToolkit,
     AsyncTool,
     AsyncToolkit,
+    BaseToolkit,
     ContextTool,
     ContextToolkit,
     Tool,
     Toolkit,
 )
-from ..base import BaseProvider, Params
+from ..base import BaseProvider, _utils as _base_utils
 from . import _utils
 from .beta_provider import AnthropicBetaProvider
 from .model_id import AnthropicModelId, model_name
 from .model_info import MODELS_WITHOUT_STRICT_STRUCTURED_OUTPUTS
 
+if TYPE_CHECKING:
+    from ...models import Params
+
 
 def _should_use_beta(
     model_id: AnthropicModelId,
-    format: type[FormattableT] | Format[FormattableT] | None,
+    format: type[FormattableT]
+    | Format[FormattableT]
+    | OutputParser[FormattableT]
+    | None,
+    tools: Sequence[AnyToolSchema] | BaseToolkit[AnyToolSchema] | None,
 ) -> bool:
-    """Determine whether to use the beta API based on format mode.
+    """Determine whether to use the beta API based on format mode or strict tools.
 
-    If the format resolves to strict mode, and the model plausibly has
-    strict structured output support, then we will use the beta provider.
+    If the format resolves to strict mode, or any tools have strict=True,
+    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":
+    if model_name(model_id) in MODELS_WITHOUT_STRICT_STRUCTURED_OUTPUTS:
         return False
-    return model_name(model_id) not in MODELS_WITHOUT_STRICT_STRUCTURED_OUTPUTS
+
+    # Check if format requires strict mode
+    resolved = resolve_format(format, default_mode=_utils.DEFAULT_FORMAT_MODE)
+    if resolved is not None and resolved.mode == "strict":
+        return True
+
+    return _base_utils.has_strict_tools(tools)
 
 
 class AnthropicProvider(BaseProvider[Anthropic]):
@@ -76,11 +94,14 @@ class AnthropicProvider(BaseProvider[Anthropic]):
         model_id: AnthropicModelId,
         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` by synchronously calling the Anthropic Messages API."""
-        if _should_use_beta(model_id, format):
+        if _should_use_beta(model_id, format, tools):
             return self._beta_provider.call(
                 model_id=model_id,
                 messages=messages,
@@ -97,8 +118,9 @@ class AnthropicProvider(BaseProvider[Anthropic]):
             params=params,
         )
         anthropic_response = self.client.messages.create(**kwargs)
+        include_thoughts = _utils.get_include_thoughts(params)
         assistant_message, finish_reason, usage = _utils.decode_response(
-            anthropic_response, model_id
+            anthropic_response, model_id, include_thoughts=include_thoughts
         )
         return Response(
             raw=anthropic_response,
@@ -123,11 +145,14 @@ class AnthropicProvider(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` by synchronously calling the Anthropic Messages API."""
-        if _should_use_beta(model_id, format):
+        if _should_use_beta(model_id, format, tools):
             return self._beta_provider.context_call(
                 ctx=ctx,
                 model_id=model_id,
@@ -145,8 +170,9 @@ class AnthropicProvider(BaseProvider[Anthropic]):
             params=params,
         )
         anthropic_response = self.client.messages.create(**kwargs)
+        include_thoughts = _utils.get_include_thoughts(params)
         assistant_message, finish_reason, usage = _utils.decode_response(
-            anthropic_response, model_id
+            anthropic_response, model_id, include_thoughts=include_thoughts
         )
         return ContextResponse(
             raw=anthropic_response,
@@ -168,11 +194,14 @@ class AnthropicProvider(BaseProvider[Anthropic]):
         model_id: AnthropicModelId,
         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` by asynchronously calling the Anthropic Messages API."""
-        if _should_use_beta(model_id, format):
+        if _should_use_beta(model_id, format, tools):
             return await self._beta_provider.call_async(
                 model_id=model_id,
                 messages=messages,
@@ -189,8 +218,9 @@ class AnthropicProvider(BaseProvider[Anthropic]):
             params=params,
         )
         anthropic_response = await self.async_client.messages.create(**kwargs)
+        include_thoughts = _utils.get_include_thoughts(params)
         assistant_message, finish_reason, usage = _utils.decode_response(
-            anthropic_response, model_id
+            anthropic_response, model_id, include_thoughts=include_thoughts
         )
         return AsyncResponse(
             raw=anthropic_response,
@@ -215,11 +245,14 @@ class AnthropicProvider(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` by asynchronously calling the Anthropic Messages API."""
-        if _should_use_beta(model_id, format):
+        if _should_use_beta(model_id, format, tools):
             return await self._beta_provider.context_call_async(
                 ctx=ctx,
                 model_id=model_id,
@@ -237,8 +270,9 @@ class AnthropicProvider(BaseProvider[Anthropic]):
             params=params,
         )
         anthropic_response = await self.async_client.messages.create(**kwargs)
+        include_thoughts = _utils.get_include_thoughts(params)
         assistant_message, finish_reason, usage = _utils.decode_response(
-            anthropic_response, model_id
+            anthropic_response, model_id, include_thoughts=include_thoughts
         )
         return AsyncContextResponse(
             raw=anthropic_response,
@@ -260,11 +294,14 @@ class AnthropicProvider(BaseProvider[Anthropic]):
         model_id: AnthropicModelId,
         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` by synchronously streaming from the Anthropic Messages API."""
-        if _should_use_beta(model_id, format):
+        if _should_use_beta(model_id, format, tools):
             return self._beta_provider.stream(
                 model_id=model_id,
                 messages=messages,
@@ -281,7 +318,10 @@ class AnthropicProvider(BaseProvider[Anthropic]):
             params=params,
         )
         anthropic_stream = self.client.messages.stream(**kwargs)
-        chunk_iterator = _utils.decode_stream(anthropic_stream)
+        include_thoughts = _utils.get_include_thoughts(params)
+        chunk_iterator = _utils.decode_stream(
+            anthropic_stream, include_thoughts=include_thoughts
+        )
         return StreamResponse(
             provider_id="anthropic",
             model_id=model_id,
@@ -302,11 +342,14 @@ class AnthropicProvider(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` by synchronously streaming from the Anthropic Messages API."""
-        if _should_use_beta(model_id, format):
+        if _should_use_beta(model_id, format, tools):
             return self._beta_provider.context_stream(
                 ctx=ctx,
                 model_id=model_id,
@@ -324,7 +367,10 @@ class AnthropicProvider(BaseProvider[Anthropic]):
             params=params,
         )
         anthropic_stream = self.client.messages.stream(**kwargs)
-        chunk_iterator = _utils.decode_stream(anthropic_stream)
+        include_thoughts = _utils.get_include_thoughts(params)
+        chunk_iterator = _utils.decode_stream(
+            anthropic_stream, include_thoughts=include_thoughts
+        )
         return ContextStreamResponse(
             provider_id="anthropic",
             model_id=model_id,
@@ -342,11 +388,14 @@ class AnthropicProvider(BaseProvider[Anthropic]):
         model_id: AnthropicModelId,
         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` by asynchronously streaming from the Anthropic Messages API."""
-        if _should_use_beta(model_id, format):
+        if _should_use_beta(model_id, format, tools):
             return await self._beta_provider.stream_async(
                 model_id=model_id,
                 messages=messages,
@@ -362,7 +411,10 @@ class AnthropicProvider(BaseProvider[Anthropic]):
             params=params,
         )
         anthropic_stream = self.async_client.messages.stream(**kwargs)
-        chunk_iterator = _utils.decode_async_stream(anthropic_stream)
+        include_thoughts = _utils.get_include_thoughts(params)
+        chunk_iterator = _utils.decode_async_stream(
+            anthropic_stream, include_thoughts=include_thoughts
+        )
         return AsyncStreamResponse(
             provider_id="anthropic",
             model_id=model_id,
@@ -383,14 +435,17 @@ class AnthropicProvider(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]
         | AsyncContextStreamResponse[DepsT, FormattableT]
     ):
         """Generate an `llm.AsyncContextStreamResponse` by asynchronously streaming from the Anthropic Messages API."""
-        if _should_use_beta(model_id, format):
+        if _should_use_beta(model_id, format, tools):
             return await self._beta_provider.context_stream_async(
                 ctx=ctx,
                 model_id=model_id,
@@ -408,7 +463,10 @@ class AnthropicProvider(BaseProvider[Anthropic]):
             params=params,
         )
         anthropic_stream = self.async_client.messages.stream(**kwargs)
-        chunk_iterator = _utils.decode_async_stream(anthropic_stream)
+        include_thoughts = _utils.get_include_thoughts(params)
+        chunk_iterator = _utils.decode_async_stream(
+            anthropic_stream, include_thoughts=include_thoughts
+        )
         return AsyncContextStreamResponse(
             provider_id="anthropic",
             model_id=model_id,

mirascope/llm/providers/base/__init__.py

@@ -3,16 +3,12 @@
 from . import _utils
 from .base_provider import BaseProvider, Provider, ProviderErrorMap
 from .kwargs import BaseKwargs, KwargsT
-from .params import Params, ThinkingConfig, ThinkingLevel
 
 __all__ = [
     "BaseKwargs",
     "BaseProvider",
     "KwargsT",
-    "Params",
     "Provider",
     "ProviderErrorMap",
-    "ThinkingConfig",
-    "ThinkingLevel",
     "_utils",
 ]

mirascope/llm/providers/base/_utils.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import logging
 from collections.abc import Generator, Sequence
 from contextlib import contextmanager
@@ -5,18 +7,44 @@ from typing import TYPE_CHECKING, TypeAlias, cast, get_type_hints
 
 from ...content import Text
 from ...messages import AssistantMessage, Message, SystemMessage, UserMessage
+from ...models.params import (
+    Params,  # Import directly from params.py to avoid circular dependency
+)
+from ...tools import AnyToolSchema, BaseToolkit
 from ..provider_id import ProviderId
-from .params import Params
 
 if TYPE_CHECKING:
+    from ...models import ThinkingConfig
     from ..model_id import ModelId
-    from .params import ThinkingConfig
 
 logger = logging.getLogger(__name__)
 
 SystemMessageContent: TypeAlias = str | None
 
 
+def get_include_thoughts(params: Params) -> bool:
+    """Extract include_thoughts from params thinking config."""
+    thinking_config = params.get("thinking")
+    return (thinking_config or {}).get("include_thoughts", False)
+
+
+def has_strict_tools(
+    tools: Sequence[AnyToolSchema] | BaseToolkit[AnyToolSchema] | None,
+) -> bool:
+    """Check if any tools have strict=True explicitly set.
+
+    Args:
+        tools: The tools to check, either a sequence or a toolkit
+
+    Returns:
+        True if any tool has strict=True, False otherwise
+    """
+    if tools is None:
+        return False
+    tools_list = tools.tools if isinstance(tools, BaseToolkit) else tools
+    return any(tool.strict is True for tool in tools_list)
+
+
 def ensure_additional_properties_false(obj: object) -> None:
     """Recursively adds additionalProperties = False to a schema, required for strict mode."""
     if isinstance(obj, dict):
@@ -31,6 +59,27 @@ def ensure_additional_properties_false(obj: object) -> None:
             ensure_additional_properties_false(item)
 
 
+def ensure_all_properties_required(obj: object) -> None:
+    """Recursively ensures all properties are in required array, needed for OpenAI strict mode.
+
+    OpenAI's strict mode requires that all properties in an object schema are listed
+    in the 'required' array, even if they have default values.
+    """
+    if isinstance(obj, dict):
+        obj = cast(dict[str, object], obj)
+        if obj.get("type") == "object" and "properties" in obj:
+            properties = obj.get("properties")
+            if isinstance(properties, dict):
+                property_keys = cast(dict[str, object], properties)
+                obj["required"] = list(property_keys.keys())
+        for value in obj.values():
+            ensure_all_properties_required(value)
+    elif isinstance(obj, list):
+        obj = cast(list[object], obj)
+        for item in obj:
+            ensure_all_properties_required(item)
+
+
 def add_system_instructions(
     messages: Sequence[Message], additional_system_instructions: str
 ) -> Sequence[Message]:
@@ -139,7 +188,7 @@ class SafeParamsAccessor:
         return self._params.get("stop_sequences")
 
     @property
-    def thinking(self) -> "ThinkingConfig | None":
+    def thinking(self) -> ThinkingConfig | None:
         """Access the thinking parameter."""
         self._unaccessed.discard("thinking")
         return self._params.get("thinking")
@@ -148,8 +197,8 @@ class SafeParamsAccessor:
         self,
         param_name: str,
         param_value: object,
-        provider_id: "ProviderId",
-        model_id: "ModelId | None" = None,
+        provider_id: ProviderId,
+        model_id: ModelId | None = None,
     ) -> None:
         unsupported_by = f"provider: {provider_id}"
         if model_id:
@@ -169,7 +218,7 @@ class SafeParamsAccessor:
 def ensure_all_params_accessed(
     *,
     params: Params,
-    provider_id: "ProviderId",
+    provider_id: ProviderId,
     unsupported_params: list[str] | None = None,
 ) -> Generator[SafeParamsAccessor, None, None]:
     """Context manager that ensures all parameters are accessed.