mirascope 1.24.1__tar.gz → 1.25.0__tar.gz

mirascope-1.25.0/.claude/settings.local.json

@@ -0,0 +1,10 @@
+{
+  "permissions": {
+    "allow": [
+      "WebFetch(domain:docs.anthropic.com)",
+      "Bash(ls:*)",
+      "Bash(rg:*)"
+    ],
+    "deny": []
+  }
+}

{mirascope-1.24.1 → mirascope-1.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mirascope
-Version: 1.24.1
+Version: 1.25.0
 Summary: LLM abstractions that aren't obstructions
 Project-URL: Homepage, https://mirascope.com
 Project-URL: Documentation, https://mirascope.com/WELCOME

mirascope-1.25.0/mirascope/core/anthropic/_thinking.py

@@ -0,0 +1,70 @@
+"""Centralized thinking-related imports and compatibility handling for Anthropic."""
+
+from typing import TYPE_CHECKING, Literal
+
+from pydantic import BaseModel
+from typing_extensions import TypedDict
+
+
+# Always define the stubs with underscore names
+class _ThinkingConfigParam(TypedDict):
+    type: Literal["enabled"]
+    budget_tokens: int
+
+
+class _ThinkingBlock(BaseModel):
+    signature: str
+    thinking: str
+    type: Literal["thinking"]
+
+
+class _ThinkingDelta(BaseModel):
+    thinking: str
+    type: Literal["thinking_delta"]
+
+
+class _SignatureDelta(BaseModel):
+    signature: str
+    type: Literal["signature_delta"]
+
+
+HAS_THINKING_SUPPORT = True
+
+# Define the public names based on what's available
+if TYPE_CHECKING:
+    # For static analysis, always use our stubs so types are consistent
+    ThinkingConfigParam = _ThinkingConfigParam
+    ThinkingBlock = _ThinkingBlock
+    ThinkingDelta = _ThinkingDelta
+    SignatureDelta = _SignatureDelta
+else:
+    # At runtime, use real types if available, otherwise stubs
+    try:
+        from anthropic.types import (  # pyright: ignore [reportAttributeAccessIssue]
+            ThinkingBlock,
+            ThinkingDelta,
+        )
+        from anthropic.types.signature_delta import (
+            SignatureDelta,  # pyright: ignore [reportMissingImports]
+        )
+        from anthropic.types.thinking_config_param import (
+            ThinkingConfigParam,  # pyright: ignore [reportMissingImports]
+        )
+
+        HAS_THINKING_SUPPORT = True
+
+    except ImportError:  # pragma: no cover
+        ThinkingConfigParam = _ThinkingConfigParam
+        ThinkingBlock = _ThinkingBlock
+        ThinkingDelta = _ThinkingDelta
+        SignatureDelta = _SignatureDelta
+        HAS_THINKING_SUPPORT = False
+
+
+__all__ = [
+    "HAS_THINKING_SUPPORT",
+    "SignatureDelta",
+    "ThinkingBlock",
+    "ThinkingConfigParam",
+    "ThinkingDelta",
+]

{mirascope-1.24.1 → mirascope-1.25.0}/mirascope/core/anthropic/_utils/_setup_call.py

@@ -19,6 +19,7 @@ from ...base import BaseMessageParam, BaseTool, _utils
 from ...base._utils import AsyncCreateFn, CreateFn
 from ...base.stream_config import StreamConfig
 from .._call_kwargs import AnthropicCallKwargs
+from .._thinking import HAS_THINKING_SUPPORT
 from ..call_params import AnthropicCallParams
 from ..dynamic_config import AnthropicDynamicConfig, AsyncAnthropicDynamicConfig
 from ..tool import AnthropicTool
@@ -95,6 +96,15 @@ def setup_call(
     list[type[AnthropicTool]] | None,
     AnthropicCallKwargs,
 ]:
+    thinking_enabled = call_params.get("thinking") is not None
+
+    # Validate thinking parameter before processing
+    if thinking_enabled and not HAS_THINKING_SUPPORT:
+        raise ValueError(  # pragma: no cover
+            "Thinking parameter requires anthropic>=0.47.0. "
+            "Please upgrade: pip install 'anthropic>=0.47.0'"
+        )
+
     prompt_template, messages, tool_types, base_call_kwargs = _utils.setup_call(
         fn,
         fn_args,
@@ -111,7 +121,9 @@ def setup_call(
     if messages[0]["role"] == "system":
         call_kwargs["system"] = messages.pop(0)["content"]  # pyright: ignore [reportGeneralTypeIssues]
 
-    if json_mode:
+    use_json_mode = json_mode or (response_model and thinking_enabled)
+
+    if use_json_mode:
         json_mode_content = _utils.json_mode_content(response_model)
         if isinstance(messages[-1]["content"], str):
             messages[-1]["content"] += json_mode_content

{mirascope-1.24.1 → mirascope-1.25.0}/mirascope/core/anthropic/call_params.py

@@ -11,6 +11,7 @@ from httpx import Timeout
 from typing_extensions import NotRequired
 
 from ..base import BaseCallParams
+from ._thinking import ThinkingConfigParam
 
 
 class AnthropicCallParams(BaseCallParams):
@@ -21,6 +22,7 @@ class AnthropicCallParams(BaseCallParams):
     Attributes:
         max_tokens: ...
         tool_choice: ...
+        thinking: ...
         metadata: ...
         stop_sequences: ...
         temperature: ...
@@ -32,6 +34,7 @@ class AnthropicCallParams(BaseCallParams):
     extra_headers: NotRequired[dict[str, str] | None]
     max_tokens: int
     tool_choice: NotRequired[ToolChoice | None]
+    thinking: NotRequired[ThinkingConfigParam | None]
     metadata: NotRequired[Metadata | None]
     stop_sequences: NotRequired[list[str] | None]
     system: NotRequired[str | Iterable[TextBlockParam] | None]

{mirascope-1.24.1 → mirascope-1.25.0}/mirascope/core/anthropic/call_response.py

@@ -71,9 +71,29 @@ class AnthropicCallResponse(
     @computed_field
     @property
     def content(self) -> str:
-        """Returns the string text of the 0th text block."""
-        block = self.response.content[0]
-        return block.text if block.type == "text" else ""
+        """Returns the text content from the first text block."""
+        for block in self.response.content:
+            if block.type == "text":
+                return block.text
+        return ""
+
+    @computed_field
+    @property
+    def thinking(self) -> str | None:
+        """Returns the thinking content from the first thinking block."""
+        for block in self.response.content:
+            if block.type == "thinking":
+                return block.thinking
+        return None
+
+    @computed_field
+    @property
+    def signature(self) -> str | None:
+        """Returns the signature from the first thinking block."""
+        for block in self.response.content:
+            if block.type == "thinking":
+                return block.signature
+        return None
 
     @computed_field
     @property

{mirascope-1.24.1 → mirascope-1.25.0}/mirascope/core/anthropic/call_response_chunk.py

@@ -61,6 +61,26 @@ class AnthropicCallResponseChunk(
             else ""
         )
 
+    @property
+    def thinking(self) -> str:
+        """Returns the thinking content from thinking deltas."""
+        return (
+            self.chunk.delta.thinking
+            if self.chunk.type == "content_block_delta"
+            and self.chunk.delta.type == "thinking_delta"
+            else ""
+        )
+
+    @property
+    def signature(self) -> str:
+        """Returns the signature content from signature deltas."""
+        return (
+            self.chunk.delta.signature
+            if self.chunk.type == "content_block_delta"
+            and self.chunk.delta.type == "signature_delta"
+            else ""
+        )
+
     @property
     def finish_reasons(self) -> list[FinishReason] | None:
         """Returns the finish reason of the response."""

{mirascope-1.24.1 → mirascope-1.25.0}/mirascope/core/anthropic/stream.py

@@ -3,6 +3,9 @@
 usage docs: learn/streams.md
 """
 
+from collections.abc import AsyncGenerator, Generator
+from typing import Any
+
 from anthropic.types import (
     Message,
     MessageParam,
@@ -16,8 +19,11 @@ from anthropic.types.text_block_param import TextBlockParam
 from anthropic.types.tool_use_block_param import ToolUseBlockParam
 from pydantic import BaseModel
 
+from ..base.call_kwargs import BaseCallKwargs
+from ..base.metadata import Metadata
 from ..base.stream import BaseStream
 from ..base.types import CostMetadata
+from ._thinking import ThinkingBlock
 from .call_params import AnthropicCallParams
 from .call_response import AnthropicCallResponse
 from .call_response_chunk import AnthropicCallResponseChunk
@@ -64,6 +70,47 @@ class AnthropicStream(
 
     _provider = "anthropic"
 
+    def __init__(
+        self,
+        *,
+        stream: Generator[
+            tuple[AnthropicCallResponseChunk, AnthropicTool | None], None, None
+        ]
+        | AsyncGenerator[tuple[AnthropicCallResponseChunk, AnthropicTool | None], None],
+        metadata: Metadata,
+        tool_types: list[type[AnthropicTool]] | None,
+        call_response_type: type[AnthropicCallResponse],
+        model: str,
+        prompt_template: str | None,
+        fn_args: dict[str, Any],
+        dynamic_config: AsyncAnthropicDynamicConfig | AnthropicDynamicConfig,
+        messages: list[MessageParam],
+        call_params: AnthropicCallParams,
+        call_kwargs: BaseCallKwargs[ToolParam],
+    ) -> None:
+        """Initialize AnthropicStream with thinking content tracking."""
+        super().__init__(
+            stream=stream,
+            metadata=metadata,
+            tool_types=tool_types,
+            call_response_type=call_response_type,
+            model=model,
+            prompt_template=prompt_template,
+            fn_args=fn_args,
+            dynamic_config=dynamic_config,
+            messages=messages,
+            call_params=call_params,
+            call_kwargs=call_kwargs,
+        )
+        self.thinking = ""
+        self.signature = ""
+
+    def _update_properties(self, chunk: AnthropicCallResponseChunk) -> None:
+        """Updates the properties of the stream, including thinking content."""
+        super()._update_properties(chunk)
+        self.thinking += chunk.thinking
+        self.signature += chunk.signature
+
     def _construct_message_param(
         self, tool_calls: list[ToolUseBlock] | None = None, content: str | None = None
     ) -> MessageParam:
@@ -102,6 +149,16 @@ class AnthropicStream(
 
         content_blocks: list[ContentBlock] = []
 
+        # Add thinking block first if we have thinking content
+        if hasattr(self, "thinking") and self.thinking:
+            content_blocks.append(
+                ThinkingBlock(  # pyright: ignore [reportArgumentType]
+                    type="thinking",
+                    thinking=self.thinking,
+                    signature=getattr(self, "signature", ""),
+                )
+            )
+
         if isinstance(self.message_param["content"], str):
             content_blocks.append(
                 TextBlock(text=self.message_param["content"], type="text")

{mirascope-1.24.1 → mirascope-1.25.0}/mirascope/core/google/call_response.py

@@ -13,6 +13,7 @@ from google.genai.types import (
     FunctionResponseDict,
     GenerateContentResponse,
     GenerateContentResponseUsageMetadata,
+    Part,
     PartDict,
     # Import manually SchemaDict to avoid Pydantic error
     SchemaDict,  # noqa: F401
@@ -72,11 +73,33 @@ class GoogleCallResponse(
 
     _provider = "google"
 
+    def _parts(self) -> list[Part]:
+        """Returns the parts of the 0th candidate."""
+        if (
+            not (candidates := self.response.candidates)
+            or not (content := candidates[0].content)
+            or not (parts := content.parts)
+        ):
+            return []
+        return parts
+
     @computed_field
     @property
     def content(self) -> str:
         """Returns the contained string content for the 0th choice."""
-        return self.response.candidates[0].content.parts[0].text  # pyright: ignore [reportOptionalSubscript, reportReturnType, reportOptionalMemberAccess, reportOptionalIterable]
+        for part in self._parts():
+            if not part.thought and part.text:
+                return part.text
+        return ""
+
+    @computed_field
+    @property
+    def thinking(self) -> str | None:
+        """Returns the thought content from the first thought part"""
+        for part in self._parts():
+            if part.thought and part.text:
+                return part.text
+        return None
 
     @computed_field
     @property

{mirascope-1.24.1 → mirascope-1.25.0}/mirascope/core/google/call_response_chunk.py

@@ -52,10 +52,28 @@ class GoogleCallResponseChunk(
             not (candidates := self.chunk.candidates)
             or not (content := candidates[0].content)
             or not (parts := content.parts)
-            or not (text := parts[0].text)
         ):
             return ""
-        return text
+
+        for part in parts:
+            if not part.thought and part.text:
+                return part.text
+        return ""
+
+    @property
+    def thinking(self) -> str:
+        """Returns the thinking content from thinking parts."""
+        if (
+            not (candidates := self.chunk.candidates)
+            or not (content := candidates[0].content)
+            or not (parts := content.parts)
+        ):
+            return ""
+
+        for part in parts:
+            if part.thought and part.text:
+                return part.text
+        return ""
 
     @property
     def finish_reasons(self) -> list[GoogleFinishReason]:

{mirascope-1.24.1 → mirascope-1.25.0}/mirascope/core/google/stream.py

@@ -3,7 +3,8 @@
 usage docs: learn/streams.md
 """
 
-from typing import cast
+from collections.abc import AsyncGenerator, Generator
+from typing import Any, cast
 
 from google.genai.types import (
     Candidate,
@@ -19,6 +20,8 @@ from google.genai.types import (
     Tool,
 )
 
+from ..base.call_kwargs import BaseCallKwargs
+from ..base.metadata import Metadata
 from ..base.stream import BaseStream
 from ..base.types import CostMetadata
 from .call_params import GoogleCallParams
@@ -64,6 +67,43 @@ class GoogleStream(
 
     _provider = "google"
 
+    def __init__(
+        self,
+        *,
+        stream: Generator[tuple[GoogleCallResponseChunk, GoogleTool | None], None, None]
+        | AsyncGenerator[tuple[GoogleCallResponseChunk, GoogleTool | None], None],
+        metadata: Metadata,
+        tool_types: list[type[GoogleTool]] | None,
+        call_response_type: type[GoogleCallResponse],
+        model: str,
+        prompt_template: str | None,
+        fn_args: dict[str, Any],
+        dynamic_config: GoogleDynamicConfig,
+        messages: list[ContentListUnion | ContentListUnionDict],
+        call_params: GoogleCallParams,
+        call_kwargs: BaseCallKwargs[Tool],
+    ) -> None:
+        """Initialize GoogleStream with thinking content tracking."""
+        super().__init__(
+            stream=stream,
+            metadata=metadata,
+            tool_types=tool_types,
+            call_response_type=call_response_type,
+            model=model,
+            prompt_template=prompt_template,
+            fn_args=fn_args,
+            dynamic_config=dynamic_config,
+            messages=messages,
+            call_params=call_params,
+            call_kwargs=call_kwargs,
+        )
+        self.thinking = ""
+
+    def _update_properties(self, chunk: GoogleCallResponseChunk) -> None:
+        """Updates the properties of the stream, including thinking content."""
+        super()._update_properties(chunk)
+        self.thinking += chunk.thinking
+
     def _construct_message_param(
         self, tool_calls: list[FunctionCall] | None = None, content: str | None = None
     ) -> ContentDict:
@@ -103,6 +143,22 @@ class GoogleStream(
         total_token_count = int(candidates_token_count or 0) + int(
             prompt_token_count or 0
         )
+
+        parts: list[PartDict] = []
+
+        # Add thinking part first if we have thinking content
+        if self.thinking:
+            parts.append({"text": self.thinking, "thought": True})
+
+        for pd in self.message_param.get("parts") or []:
+            if pd.get("text") == "":
+                # These parts are generated based only on chunk content;
+                # thinking parts have empty content and are reconstructed separately.
+                # Skip this so the thinking parts aren't duplicated.
+                continue
+            else:
+                parts.append(pd)
+
         response = GenerateContentResponse(
             candidates=[
                 Candidate(
@@ -111,7 +167,7 @@ class GoogleStream(
                     else FinishReason.STOP,
                     content=Content(
                         role=self.message_param["role"],  # pyright: ignore [reportTypedDictNotRequiredAccess]
-                        parts=self.message_param["parts"],  # pyright: ignore [reportTypedDictNotRequiredAccess, reportArgumentType]
+                        parts=parts,  # pyright: ignore [reportArgumentType]
                     ),
                 )
             ],

{mirascope-1.24.1 → mirascope-1.25.0}/mirascope/mcp/_utils.py

@@ -22,6 +22,8 @@ from pydantic import BaseModel, ConfigDict, Field, create_model
 from ..core import BaseMessageParam, BaseTool
 from ..core.base import AudioPart, DocumentPart, ImagePart
 
+_UNSET = object()
+
 
 def create_tool_call(
     name: str,
@@ -38,7 +40,8 @@ def create_tool_call(
     """
 
     async def call(self: BaseTool) -> list[str | ImageContent | EmbeddedResource]:
-        result = await call_tool(name, self.args)  # pyright: ignore [reportOptionalCall]
+        args = {key: value for key, value in self.args.items() if value is not _UNSET}
+        result = await call_tool(name, args if args else None)
         if result.isError:
             raise RuntimeError(f"MCP Server returned error: {self._name()}")
         return [
@@ -225,15 +228,18 @@ def create_tool_from_mcp_tool(tool: MCPTool) -> type[BaseTool]:
     fields = {}
     for field_name, field_schema in properties.items():
         field_type = json_schema_to_python_type(field_schema)
+        if field_schema.get("nullable", False):
+            field_type = field_type | None
 
-        if field_name in required_fields:
-            default = Field(..., description=field_schema.get("description"))
-            annotation = field_type
-        else:
-            default = Field(None, description=field_schema.get("description"))
-            annotation = field_type | None
+        field_info = {
+            "default": field_schema.get(
+                "default", ... if field_name in required_fields else _UNSET
+            )
+        }
+        if description := field_schema.get("description", ""):
+            field_info["description"] = description
 
-        fields[field_name] = (annotation, default)
+        fields[field_name] = (field_type, Field(**field_info))
 
     return create_model(snake_to_pascal(tool.name), __base__=BaseTool, **fields)
 

{mirascope-1.24.1 → mirascope-1.25.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mirascope"
-version = "1.24.1"
+version = "1.25.0"
 description = "LLM abstractions that aren't obstructions"
 readme = "README.md"
 license = { file = "LICENSE" }

{mirascope-1.24.1 → mirascope-1.25.0}/tests/core/anthropic/_utils/test_setup_call.py

@@ -179,3 +179,45 @@ def test_setup_call_extract(
         "type": "tool",
         "name": tool_types[0]._name(),
     }
+
+
+@patch(
+    "mirascope.core.anthropic._utils._setup_call.convert_message_params",
+    new_callable=MagicMock,
+)
+@patch("mirascope.core.anthropic._utils._setup_call._utils", new_callable=MagicMock)
+def test_setup_call_thinking_with_response_model(
+    mock_utils: MagicMock,
+    mock_convert_message_params: MagicMock,
+    mock_base_setup_call: MagicMock,
+) -> None:
+    """Tests that response_model with thinking automatically uses JSON mode."""
+    mock_utils.setup_call = mock_base_setup_call
+    mock_utils.json_mode_content = MagicMock(return_value="\n\njson_instructions")
+    mock_base_setup_call.return_value[1] = [{"role": "user", "content": "test message"}]
+    mock_base_setup_call.return_value[2] = [
+        MagicMock(spec=AnthropicTool, __name__="tool")
+    ]
+    mock_base_setup_call.return_value[3] = {"max_tokens": 1000}
+    mock_convert_message_params.side_effect = lambda x: x
+
+    _, _, messages, tool_types, call_kwargs = setup_call(
+        model="claude-3-5-sonnet-20240620",
+        client=None,
+        fn=MagicMock(),
+        fn_args={},
+        dynamic_config=None,
+        tools=None,
+        json_mode=False,
+        call_params={
+            "max_tokens": 1000,
+            "thinking": {"type": "enabled", "budget_tokens": 1000},
+        },
+        response_model=BaseModel,
+        stream=False,
+    )
+
+    # Should automatically use JSON mode instead of forced tool calling
+    assert "tool_choice" not in call_kwargs
+    assert messages[-1]["content"] == "test message\n\njson_instructions"  # type: ignore
+    mock_utils.json_mode_content.assert_called_once_with(BaseModel)