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

mirascope/llm/prompts/prompts.py

@@ -1,11 +1,15 @@
 """Concrete Prompt classes for generating messages with tools and formatting."""
 
-from dataclasses import dataclass
-from typing import Generic, overload
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass, field
+from typing import Any, Generic, TypeVar, overload
 
+from ..._utils import copy_function_metadata
 from ..context import Context, DepsT
-from ..formatting import Format, FormattableT
+from ..formatting import Format, FormattableT, OutputParser
+from ..messages import Message, promote_to_messages
 from ..models import Model
+from ..providers import ModelId
 from ..responses import (
     AsyncContextResponse,
     AsyncContextStreamResponse,
@@ -16,14 +20,8 @@ from ..responses import (
     Response,
     StreamResponse,
 )
-from ..tools import (
-    AsyncContextToolkit,
-    AsyncToolkit,
-    ContextToolkit,
-    Toolkit,
-)
+from ..tools import AsyncContextToolkit, AsyncToolkit, ContextToolkit, Toolkit
 from ..types import P
-from . import _utils
 from .protocols import (
     AsyncContextMessageTemplate,
     AsyncMessageTemplate,
@@ -31,9 +29,26 @@ from .protocols import (
     MessageTemplate,
 )
 
+FunctionT = TypeVar("FunctionT", bound=Callable[..., Any])
+
+
+@dataclass(kw_only=True)
+class BasePrompt(Generic[FunctionT]):
+    """Base class for all Prompt types with shared metadata functionality."""
+
+    fn: FunctionT
+    """The underlying prompt function that generates message content."""
+
+    __name__: str = field(init=False, repr=False, default="")
+    """The name of the underlying function (preserved for decorator stacking)."""
+
+    def __post_init__(self) -> None:
+        """Preserve standard function attributes for decorator stacking."""
+        copy_function_metadata(self, self.fn)
+
 
 @dataclass
-class Prompt(Generic[P, FormattableT]):
+class Prompt(BasePrompt[MessageTemplate[P]], Generic[P, FormattableT]):
     """A prompt that can be called with a model to generate a response.
 
     Created by decorating a `MessageTemplate` with `llm.prompt`. The decorated
@@ -43,70 +58,93 @@ class Prompt(Generic[P, FormattableT]):
     It can be invoked with a model: `prompt(model, *args, **kwargs)`.
     """
 
-    fn: MessageTemplate[P]
-    """The underlying prompt function that generates message content."""
-
     toolkit: Toolkit
     """The toolkit containing this prompt's tools."""
 
-    format: type[FormattableT] | Format[FormattableT] | None
+    format: (
+        type[FormattableT] | Format[FormattableT] | OutputParser[FormattableT] | None
+    )
     """The response format for the generated response."""
 
+    def messages(self, *args: P.args, **kwargs: P.kwargs) -> Sequence[Message]:
+        """Return the `Messages` from invoking this prompt."""
+        return promote_to_messages(self.fn(*args, **kwargs))
+
     @overload
     def __call__(
-        self: "Prompt[P, None]", model: Model, *args: P.args, **kwargs: P.kwargs
+        self: "Prompt[P, None]",
+        model: Model | ModelId,
+        *args: P.args,
+        **kwargs: P.kwargs,
     ) -> Response: ...
 
     @overload
     def __call__(
-        self: "Prompt[P, FormattableT]", model: Model, *args: P.args, **kwargs: P.kwargs
+        self: "Prompt[P, FormattableT]",
+        model: Model | ModelId,
+        *args: P.args,
+        **kwargs: P.kwargs,
     ) -> Response[FormattableT]: ...
 
     def __call__(
-        self, model: Model, *args: P.args, **kwargs: P.kwargs
+        self, model: Model | ModelId, *args: P.args, **kwargs: P.kwargs
     ) -> Response | Response[FormattableT]:
         """Generates a response using the provided model."""
         return self.call(model, *args, **kwargs)
 
     @overload
     def call(
-        self: "Prompt[P, None]", model: Model, *args: P.args, **kwargs: P.kwargs
+        self: "Prompt[P, None]",
+        model: Model | ModelId,
+        *args: P.args,
+        **kwargs: P.kwargs,
     ) -> Response: ...
 
     @overload
     def call(
-        self: "Prompt[P, FormattableT]", model: Model, *args: P.args, **kwargs: P.kwargs
+        self: "Prompt[P, FormattableT]",
+        model: Model | ModelId,
+        *args: P.args,
+        **kwargs: P.kwargs,
     ) -> Response[FormattableT]: ...
 
     def call(
-        self, model: Model, *args: P.args, **kwargs: P.kwargs
+        self, model: Model | ModelId, *args: P.args, **kwargs: P.kwargs
     ) -> Response | Response[FormattableT]:
         """Generates a response using the provided model."""
-        result = self.fn(*args, **kwargs)
-        messages = _utils.promote_to_messages(result)
-        return model.call(messages=messages, tools=self.toolkit, format=self.format)
+        if isinstance(model, str):
+            model = Model(model)
+        messages = self.messages(*args, **kwargs)
+        return model.call(messages, tools=self.toolkit, format=self.format)
 
     @overload
     def stream(
-        self: "Prompt[P, None]", model: Model, *args: P.args, **kwargs: P.kwargs
+        self: "Prompt[P, None]",
+        model: Model | ModelId,
+        *args: P.args,
+        **kwargs: P.kwargs,
     ) -> StreamResponse: ...
 
     @overload
     def stream(
-        self: "Prompt[P, FormattableT]", model: Model, *args: P.args, **kwargs: P.kwargs
+        self: "Prompt[P, FormattableT]",
+        model: Model | ModelId,
+        *args: P.args,
+        **kwargs: P.kwargs,
     ) -> StreamResponse[FormattableT]: ...
 
     def stream(
-        self, model: Model, *args: P.args, **kwargs: P.kwargs
+        self, model: Model | ModelId, *args: P.args, **kwargs: P.kwargs
     ) -> StreamResponse | StreamResponse[FormattableT]:
         """Generates a streaming response using the provided model."""
-        result = self.fn(*args, **kwargs)
-        messages = _utils.promote_to_messages(result)
-        return model.stream(messages=messages, tools=self.toolkit, format=self.format)
+        if isinstance(model, str):
+            model = Model(model)
+        messages = self.messages(*args, **kwargs)
+        return model.stream(messages, tools=self.toolkit, format=self.format)
 
 
 @dataclass
-class AsyncPrompt(Generic[P, FormattableT]):
+class AsyncPrompt(BasePrompt[AsyncMessageTemplate[P]], Generic[P, FormattableT]):
     """An async prompt that can be called with a model to generate a response.
 
     Created by decorating an async `MessageTemplate` with `llm.prompt`. The decorated
@@ -116,83 +154,97 @@ class AsyncPrompt(Generic[P, FormattableT]):
     It can be invoked with a model: `await prompt(model, *args, **kwargs)`.
     """
 
-    fn: AsyncMessageTemplate[P]
-    """The underlying async prompt function that generates message content."""
-
     toolkit: AsyncToolkit
     """The toolkit containing this prompt's async tools."""
 
-    format: type[FormattableT] | Format[FormattableT] | None
+    format: (
+        type[FormattableT] | Format[FormattableT] | OutputParser[FormattableT] | None
+    )
     """The response format for the generated response."""
 
+    async def messages(self, *args: P.args, **kwargs: P.kwargs) -> Sequence[Message]:
+        """Return the `Messages` from invoking this prompt."""
+        return promote_to_messages(await self.fn(*args, **kwargs))
+
     @overload
     async def __call__(
-        self: "AsyncPrompt[P, None]", model: Model, *args: P.args, **kwargs: P.kwargs
+        self: "AsyncPrompt[P, None]",
+        model: Model | ModelId,
+        *args: P.args,
+        **kwargs: P.kwargs,
     ) -> AsyncResponse: ...
 
     @overload
     async def __call__(
         self: "AsyncPrompt[P, FormattableT]",
-        model: Model,
+        model: Model | ModelId,
         *args: P.args,
         **kwargs: P.kwargs,
     ) -> AsyncResponse[FormattableT]: ...
 
     async def __call__(
-        self, model: Model, *args: P.args, **kwargs: P.kwargs
+        self, model: Model | ModelId, *args: P.args, **kwargs: P.kwargs
     ) -> AsyncResponse | AsyncResponse[FormattableT]:
         """Generates a response using the provided model asynchronously."""
         return await self.call(model, *args, **kwargs)
 
     @overload
     async def call(
-        self: "AsyncPrompt[P, None]", model: Model, *args: P.args, **kwargs: P.kwargs
+        self: "AsyncPrompt[P, None]",
+        model: Model | ModelId,
+        *args: P.args,
+        **kwargs: P.kwargs,
     ) -> AsyncResponse: ...
 
     @overload
     async def call(
         self: "AsyncPrompt[P, FormattableT]",
-        model: Model,
+        model: Model | ModelId,
         *args: P.args,
         **kwargs: P.kwargs,
     ) -> AsyncResponse[FormattableT]: ...
 
     async def call(
-        self, model: Model, *args: P.args, **kwargs: P.kwargs
+        self, model: Model | ModelId, *args: P.args, **kwargs: P.kwargs
     ) -> AsyncResponse | AsyncResponse[FormattableT]:
         """Generates a response using the provided model asynchronously."""
-        result = await self.fn(*args, **kwargs)
-        messages = _utils.promote_to_messages(result)
-        return await model.call_async(
-            messages=messages, tools=self.toolkit, format=self.format
-        )
+        if isinstance(model, str):
+            model = Model(model)
+        messages = await self.messages(*args, **kwargs)
+        return await model.call_async(messages, tools=self.toolkit, format=self.format)
 
     @overload
     async def stream(
-        self: "AsyncPrompt[P, None]", model: Model, *args: P.args, **kwargs: P.kwargs
+        self: "AsyncPrompt[P, None]",
+        model: Model | ModelId,
+        *args: P.args,
+        **kwargs: P.kwargs,
     ) -> AsyncStreamResponse: ...
 
     @overload
     async def stream(
         self: "AsyncPrompt[P, FormattableT]",
-        model: Model,
+        model: Model | ModelId,
         *args: P.args,
         **kwargs: P.kwargs,
     ) -> AsyncStreamResponse[FormattableT]: ...
 
     async def stream(
-        self, model: Model, *args: P.args, **kwargs: P.kwargs
+        self, model: Model | ModelId, *args: P.args, **kwargs: P.kwargs
     ) -> AsyncStreamResponse | AsyncStreamResponse[FormattableT]:
         """Generates a streaming response using the provided model asynchronously."""
-        result = await self.fn(*args, **kwargs)
-        messages = _utils.promote_to_messages(result)
+        if isinstance(model, str):
+            model = Model(model)
+        messages = await self.messages(*args, **kwargs)
         return await model.stream_async(
-            messages=messages, tools=self.toolkit, format=self.format
+            messages, tools=self.toolkit, format=self.format
         )
 
 
 @dataclass
-class ContextPrompt(Generic[P, DepsT, FormattableT]):
+class ContextPrompt(
+    BasePrompt[ContextMessageTemplate[P, DepsT]], Generic[P, DepsT, FormattableT]
+):
     """A context-aware prompt that can be called with a model to generate a response.
 
     Created by decorating a `ContextMessageTemplate` with `llm.prompt`. The decorated
@@ -203,19 +255,24 @@ class ContextPrompt(Generic[P, DepsT, FormattableT]):
     It can be invoked with a model: `prompt(model, ctx, *args, **kwargs)`.
     """
 
-    fn: ContextMessageTemplate[P, DepsT]
-    """The underlying context-aware prompt function that generates message content."""
-
     toolkit: ContextToolkit[DepsT]
     """The toolkit containing this prompt's context-aware tools."""
 
-    format: type[FormattableT] | Format[FormattableT] | None
+    format: (
+        type[FormattableT] | Format[FormattableT] | OutputParser[FormattableT] | None
+    )
     """The response format for the generated response."""
 
+    def messages(
+        self, ctx: Context[DepsT], *args: P.args, **kwargs: P.kwargs
+    ) -> Sequence[Message]:
+        """Return the `Messages` from invoking this prompt."""
+        return promote_to_messages(self.fn(ctx, *args, **kwargs))
+
     @overload
     def __call__(
         self: "ContextPrompt[P, DepsT, None]",
-        model: Model,
+        model: Model | ModelId,
         ctx: Context[DepsT],
         *args: P.args,
         **kwargs: P.kwargs,
@@ -224,7 +281,7 @@ class ContextPrompt(Generic[P, DepsT, FormattableT]):
     @overload
     def __call__(
         self: "ContextPrompt[P, DepsT, FormattableT]",
-        model: Model,
+        model: Model | ModelId,
         ctx: Context[DepsT],
         *args: P.args,
         **kwargs: P.kwargs,
@@ -232,7 +289,7 @@ class ContextPrompt(Generic[P, DepsT, FormattableT]):
 
     def __call__(
         self,
-        model: Model,
+        model: Model | ModelId,
         ctx: Context[DepsT],
         *args: P.args,
         **kwargs: P.kwargs,
@@ -243,7 +300,7 @@ class ContextPrompt(Generic[P, DepsT, FormattableT]):
     @overload
     def call(
         self: "ContextPrompt[P, DepsT, None]",
-        model: Model,
+        model: Model | ModelId,
         ctx: Context[DepsT],
         *args: P.args,
         **kwargs: P.kwargs,
@@ -252,7 +309,7 @@ class ContextPrompt(Generic[P, DepsT, FormattableT]):
     @overload
     def call(
         self: "ContextPrompt[P, DepsT, FormattableT]",
-        model: Model,
+        model: Model | ModelId,
         ctx: Context[DepsT],
         *args: P.args,
         **kwargs: P.kwargs,
@@ -260,22 +317,23 @@ class ContextPrompt(Generic[P, DepsT, FormattableT]):
 
     def call(
         self,
-        model: Model,
+        model: Model | ModelId,
         ctx: Context[DepsT],
         *args: P.args,
         **kwargs: P.kwargs,
     ) -> ContextResponse[DepsT, None] | ContextResponse[DepsT, FormattableT]:
         """Generates a response using the provided model."""
-        result = self.fn(ctx, *args, **kwargs)
-        messages = _utils.promote_to_messages(result)
+        if isinstance(model, str):
+            model = Model(model)
+        messages = self.messages(ctx, *args, **kwargs)
         return model.context_call(
-            ctx=ctx, messages=messages, tools=self.toolkit, format=self.format
+            messages, ctx=ctx, tools=self.toolkit, format=self.format
         )
 
     @overload
     def stream(
         self: "ContextPrompt[P, DepsT, None]",
-        model: Model,
+        model: Model | ModelId,
         ctx: Context[DepsT],
         *args: P.args,
         **kwargs: P.kwargs,
@@ -284,7 +342,7 @@ class ContextPrompt(Generic[P, DepsT, FormattableT]):
     @overload
     def stream(
         self: "ContextPrompt[P, DepsT, FormattableT]",
-        model: Model,
+        model: Model | ModelId,
         ctx: Context[DepsT],
         *args: P.args,
         **kwargs: P.kwargs,
@@ -292,7 +350,7 @@ class ContextPrompt(Generic[P, DepsT, FormattableT]):
 
     def stream(
         self,
-        model: Model,
+        model: Model | ModelId,
         ctx: Context[DepsT],
         *args: P.args,
         **kwargs: P.kwargs,
@@ -300,15 +358,18 @@ class ContextPrompt(Generic[P, DepsT, FormattableT]):
         ContextStreamResponse[DepsT, None] | ContextStreamResponse[DepsT, FormattableT]
     ):
         """Generates a streaming response using the provided model."""
-        result = self.fn(ctx, *args, **kwargs)
-        messages = _utils.promote_to_messages(result)
+        if isinstance(model, str):
+            model = Model(model)
+        messages = self.messages(ctx, *args, **kwargs)
         return model.context_stream(
-            ctx=ctx, messages=messages, tools=self.toolkit, format=self.format
+            messages, ctx=ctx, tools=self.toolkit, format=self.format
         )
 
 
 @dataclass
-class AsyncContextPrompt(Generic[P, DepsT, FormattableT]):
+class AsyncContextPrompt(
+    BasePrompt[AsyncContextMessageTemplate[P, DepsT]], Generic[P, DepsT, FormattableT]
+):
     """An async context-aware prompt that can be called with a model to generate a response.
 
     Created by decorating an async `ContextMessageTemplate` with `llm.prompt`. The decorated
@@ -319,19 +380,24 @@ class AsyncContextPrompt(Generic[P, DepsT, FormattableT]):
     It can be invoked with a model: `await prompt(model, ctx, *args, **kwargs)`.
     """
 
-    fn: AsyncContextMessageTemplate[P, DepsT]
-    """The underlying async context-aware prompt function that generates message content."""
-
     toolkit: AsyncContextToolkit[DepsT]
     """The toolkit containing this prompt's async context-aware tools."""
 
-    format: type[FormattableT] | Format[FormattableT] | None
+    format: (
+        type[FormattableT] | Format[FormattableT] | OutputParser[FormattableT] | None
+    )
     """The response format for the generated response."""
 
+    async def messages(
+        self, ctx: Context[DepsT], *args: P.args, **kwargs: P.kwargs
+    ) -> Sequence[Message]:
+        """Return the `Messages` from invoking this prompt."""
+        return promote_to_messages(await self.fn(ctx, *args, **kwargs))
+
     @overload
     async def __call__(
         self: "AsyncContextPrompt[P, DepsT, None]",
-        model: Model,
+        model: Model | ModelId,
         ctx: Context[DepsT],
         *args: P.args,
         **kwargs: P.kwargs,
@@ -340,7 +406,7 @@ class AsyncContextPrompt(Generic[P, DepsT, FormattableT]):
     @overload
     async def __call__(
         self: "AsyncContextPrompt[P, DepsT, FormattableT]",
-        model: Model,
+        model: Model | ModelId,
         ctx: Context[DepsT],
         *args: P.args,
         **kwargs: P.kwargs,
@@ -348,7 +414,7 @@ class AsyncContextPrompt(Generic[P, DepsT, FormattableT]):
 
     async def __call__(
         self,
-        model: Model,
+        model: Model | ModelId,
         ctx: Context[DepsT],
         *args: P.args,
         **kwargs: P.kwargs,
@@ -359,7 +425,7 @@ class AsyncContextPrompt(Generic[P, DepsT, FormattableT]):
     @overload
     async def call(
         self: "AsyncContextPrompt[P, DepsT, None]",
-        model: Model,
+        model: Model | ModelId,
         ctx: Context[DepsT],
         *args: P.args,
         **kwargs: P.kwargs,
@@ -368,7 +434,7 @@ class AsyncContextPrompt(Generic[P, DepsT, FormattableT]):
     @overload
     async def call(
         self: "AsyncContextPrompt[P, DepsT, FormattableT]",
-        model: Model,
+        model: Model | ModelId,
         ctx: Context[DepsT],
         *args: P.args,
         **kwargs: P.kwargs,
@@ -376,22 +442,23 @@ class AsyncContextPrompt(Generic[P, DepsT, FormattableT]):
 
     async def call(
         self,
-        model: Model,
+        model: Model | ModelId,
         ctx: Context[DepsT],
         *args: P.args,
         **kwargs: P.kwargs,
     ) -> AsyncContextResponse[DepsT, None] | AsyncContextResponse[DepsT, FormattableT]:
         """Generates a response using the provided model asynchronously."""
-        result = await self.fn(ctx, *args, **kwargs)
-        messages = _utils.promote_to_messages(result)
+        if isinstance(model, str):
+            model = Model(model)
+        messages = await self.messages(ctx, *args, **kwargs)
         return await model.context_call_async(
-            ctx=ctx, messages=messages, tools=self.toolkit, format=self.format
+            messages, ctx=ctx, tools=self.toolkit, format=self.format
         )
 
     @overload
     async def stream(
         self: "AsyncContextPrompt[P, DepsT, None]",
-        model: Model,
+        model: Model | ModelId,
         ctx: Context[DepsT],
         *args: P.args,
         **kwargs: P.kwargs,
@@ -400,7 +467,7 @@ class AsyncContextPrompt(Generic[P, DepsT, FormattableT]):
     @overload
     async def stream(
         self: "AsyncContextPrompt[P, DepsT, FormattableT]",
-        model: Model,
+        model: Model | ModelId,
         ctx: Context[DepsT],
         *args: P.args,
         **kwargs: P.kwargs,
@@ -408,7 +475,7 @@ class AsyncContextPrompt(Generic[P, DepsT, FormattableT]):
 
     async def stream(
         self,
-        model: Model,
+        model: Model | ModelId,
         ctx: Context[DepsT],
         *args: P.args,
         **kwargs: P.kwargs,
@@ -417,8 +484,9 @@ class AsyncContextPrompt(Generic[P, DepsT, FormattableT]):
         | AsyncContextStreamResponse[DepsT, FormattableT]
     ):
         """Generates a streaming response using the provided model asynchronously."""
-        result = await self.fn(ctx, *args, **kwargs)
-        messages = _utils.promote_to_messages(result)
+        if isinstance(model, str):
+            model = Model(model)
+        messages = await self.messages(ctx, *args, **kwargs)
         return await model.context_stream_async(
-            ctx=ctx, messages=messages, tools=self.toolkit, format=self.format
+            messages, ctx=ctx, tools=self.toolkit, format=self.format
         )

mirascope/llm/providers/__init__.py

@@ -19,7 +19,7 @@ from .anthropic import (
     AnthropicModelId,
     AnthropicProvider,
 )
-from .base import BaseProvider, Params, Provider, ThinkingConfig, ThinkingLevel
+from .base import BaseProvider, Provider
 from .google import GoogleModelId, GoogleProvider
 from .mirascope import MirascopeProvider
 from .mlx import MLXModelId, MLXProvider
@@ -53,11 +53,8 @@ __all__ = [
     "OllamaProvider",
     "OpenAIModelId",
     "OpenAIProvider",
-    "Params",
     "Provider",
     "ProviderId",
-    "ThinkingConfig",
-    "ThinkingLevel",
     "TogetherProvider",
     "get_provider_for_model",
     "register_provider",

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

@@ -1,5 +1,6 @@
 """Shared Anthropic utilities."""
 
+from ...base._utils import get_include_thoughts
 from .decode import decode_async_stream, decode_response, decode_stream
 from .encode import (
     DEFAULT_FORMAT_MODE,
@@ -21,5 +22,6 @@ __all__ = [
     "decode_stream",
     "encode_image_mime_type",
     "encode_request",
+    "get_include_thoughts",
     "process_params",
 ]

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

@@ -74,10 +74,15 @@ def _decode_beta_assistant_content(content: BetaContentBlock) -> AssistantConten
 def beta_decode_response(
     response: ParsedBetaMessage[Any],
     model_id: str,
+    *,
+    include_thoughts: bool,
 ) -> tuple[AssistantMessage, FinishReason | None, Usage]:
     """Convert Beta message to mirascope AssistantMessage and usage."""
+    content = [_decode_beta_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_beta_assistant_content(part) for part in response.content],
+        content=content,
         provider_id="anthropic",
         model_id=model_id,
         provider_model_name=model_name(model_id),
@@ -108,10 +113,11 @@ BetaContentBlockParam: TypeAlias = (
 class _BetaChunkProcessor:
     """Processes Beta stream events and maintains state across events."""
 
-    def __init__(self) -> None:
+    def __init__(self, *, include_thoughts: bool) -> None:
         self.current_block_param: BetaContentBlockParam | None = None
         self.accumulated_tool_json: str = ""
         self.accumulated_blocks: list[BetaContentBlockParam] = []
+        self.include_thoughts = include_thoughts
 
     def process_event(self, event: BetaRawMessageStreamEvent) -> ChunkIterator:
         """Process a single Beta event and yield the appropriate content chunks."""
@@ -144,7 +150,8 @@ class _BetaChunkProcessor:
                     "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",
@@ -183,7 +190,8 @@ class _BetaChunkProcessor:
                         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(
@@ -215,7 +223,8 @@ class _BetaChunkProcessor:
                 )
                 yield ToolCallEndChunk(id=self.current_block_param["id"])
             elif block_type == "thinking":
-                yield ThoughtEndChunk()
+                if self.include_thoughts:
+                    yield ThoughtEndChunk()
             else:
                 raise NotImplementedError
 
@@ -251,10 +260,10 @@ class _BetaChunkProcessor:
 
 
 def beta_decode_stream(
-    beta_stream_manager: BetaMessageStreamManager[Any],
+    beta_stream_manager: BetaMessageStreamManager[Any], *, include_thoughts: bool
 ) -> ChunkIterator:
     """Returns a ChunkIterator converted from a Beta MessageStreamManager."""
-    processor = _BetaChunkProcessor()
+    processor = _BetaChunkProcessor(include_thoughts=include_thoughts)
     with beta_stream_manager as stream:
         for event in stream._raw_stream:  # pyright: ignore[reportPrivateUsage]
             yield from processor.process_event(event)
@@ -262,10 +271,10 @@ def beta_decode_stream(
 
 
 async def beta_decode_async_stream(
-    beta_stream_manager: BetaAsyncMessageStreamManager[Any],
+    beta_stream_manager: BetaAsyncMessageStreamManager[Any], *, include_thoughts: bool
 ) -> AsyncChunkIterator:
     """Returns an AsyncChunkIterator converted from a Beta MessageStreamManager."""
-    processor = _BetaChunkProcessor()
+    processor = _BetaChunkProcessor(include_thoughts=include_thoughts)
     async with beta_stream_manager as stream:
         async for event in stream._raw_stream:  # pyright: ignore[reportPrivateUsage]
             for item in processor.process_event(event):