mirascope 2.0.0__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

mirascope/llm/clients/anthropic/model_ids.py

@@ -0,0 +1,8 @@
+"""Anthropic registered LLM models."""
+
+from typing import TypeAlias
+
+import anthropic
+
+AnthropicModelId: TypeAlias = anthropic.types.Model
+"""The Anthropic model ids registered with Mirascope."""

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

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

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

@@ -1,85 +1,20 @@
-from __future__ import annotations
-
 import logging
 from collections.abc import Generator, Sequence
 from contextlib import contextmanager
-from typing import TYPE_CHECKING, TypeAlias, cast, get_type_hints
+from typing import TYPE_CHECKING, TypeAlias, 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 ..providers import ModelId, Provider
 
 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):
-        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 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]:
@@ -126,8 +61,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: SystemMessageContent = None
-    remaining_messages: list[UserMessage | AssistantMessage] = []
+    system_message_content = None
+    remaining_messages = []
 
     for i, message in enumerate(messages):
         if message.role == "system":
@@ -188,19 +123,25 @@ class SafeParamsAccessor:
         return self._params.get("stop_sequences")
 
     @property
-    def thinking(self) -> ThinkingConfig | None:
+    def thinking(self) -> bool | 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,
         param_value: object,
-        provider_id: ProviderId,
-        model_id: ModelId | None = None,
+        provider: "Provider",
+        model_id: "ModelId | None" = None,
     ) -> None:
-        unsupported_by = f"provider: {provider_id}"
+        unsupported_by = f"provider: {provider}"
         if model_id:
             unsupported_by += f" with model_id: {model_id}"
         logger.warning(
@@ -218,7 +159,7 @@ class SafeParamsAccessor:
 def ensure_all_params_accessed(
     *,
     params: Params,
-    provider_id: ProviderId,
+    provider: "Provider",
     unsupported_params: list[str] | None = None,
 ) -> Generator[SafeParamsAccessor, None, None]:
     """Context manager that ensures all parameters are accessed.
@@ -244,9 +185,7 @@ 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_id=provider_id
-            )
+            accessor.emit_warning_for_unused_param(unsupported, val, provider=provider)
     try:
         yield accessor
     finally: