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

mirascope/llm/prompts/prompts.py

@@ -1,11 +1,14 @@
 """Concrete Prompt classes for generating messages with tools and formatting."""
 
+from collections.abc import Sequence
 from dataclasses import dataclass
 from typing import Generic, overload
 
 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,
@@ -23,7 +26,6 @@ from ..tools import (
     Toolkit,
 )
 from ..types import P
-from . import _utils
 from .protocols import (
     AsyncContextMessageTemplate,
     AsyncMessageTemplate,
@@ -49,60 +51,86 @@ class Prompt(Generic[P, FormattableT]):
     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
@@ -122,72 +150,87 @@ class AsyncPrompt(Generic[P, FormattableT]):
     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
         )
 
 
@@ -209,13 +252,21 @@ class ContextPrompt(Generic[P, DepsT, FormattableT]):
     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 +275,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 +283,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 +294,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 +303,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 +311,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 +336,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 +344,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,10 +352,11 @@ 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
         )
 
 
@@ -325,13 +378,21 @@ class AsyncContextPrompt(Generic[P, DepsT, FormattableT]):
     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 +401,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 +409,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 +420,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 +429,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 +437,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 +462,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 +470,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 +479,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

@@ -1,11 +1,27 @@
 """Interfaces for LLM providers."""
 
+from ..._stubs import stub_module_if_missing
+
+# Stub modules for missing optional dependencies BEFORE importing
+# This must happen before any imports from these modules
+# Note: We only stub top-level provider modules, not their submodules.
+# The _StubModule will automatically handle nested attribute access.
+stub_module_if_missing("mirascope.llm.providers.anthropic", "anthropic")
+stub_module_if_missing("mirascope.llm.providers.google", "google")
+stub_module_if_missing("mirascope.llm.providers.mlx", "mlx")
+stub_module_if_missing("mirascope.llm.providers.openai", "openai")
+stub_module_if_missing("mirascope.llm.providers.together", "openai")
+stub_module_if_missing("mirascope.llm.providers.ollama", "openai")
+
+# Now imports work regardless of which packages are installed
+# ruff: noqa: E402
 from .anthropic import (
     AnthropicModelId,
     AnthropicProvider,
 )
-from .base import BaseProvider, Params, Provider
+from .base import BaseProvider, Provider
 from .google import GoogleModelId, GoogleProvider
+from .mirascope import MirascopeProvider
 from .mlx import MLXModelId, MLXProvider
 from .model_id import ModelId
 from .ollama import OllamaProvider
@@ -32,11 +48,11 @@ __all__ = [
     "GoogleProvider",
     "MLXModelId",
     "MLXProvider",
+    "MirascopeProvider",
     "ModelId",
     "OllamaProvider",
     "OpenAIModelId",
     "OpenAIProvider",
-    "Params",
     "Provider",
     "ProviderId",
     "TogetherProvider",

mirascope/llm/providers/anthropic/__init__.py

@@ -1,26 +1,8 @@
 """Anthropic client implementation."""
 
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from .beta_provider import AnthropicBetaProvider
-    from .model_id import AnthropicModelId
-    from .provider import AnthropicProvider
-else:
-    try:
-        from .beta_provider import AnthropicBetaProvider
-        from .model_id import AnthropicModelId
-        from .provider import AnthropicProvider
-    except ImportError:  # pragma: no cover
-        from .._missing_import_stubs import (
-            create_provider_stub,
-        )
-
-        AnthropicBetaProvider = create_provider_stub(
-            "anthropic", "AnthropicBetaProvider"
-        )
-        AnthropicProvider = create_provider_stub("anthropic", "AnthropicProvider")
-        AnthropicModelId = str
+from .beta_provider import AnthropicBetaProvider
+from .model_id import AnthropicModelId
+from .provider import AnthropicProvider
 
 __all__ = [
     "AnthropicBetaProvider",

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",
@@ -174,14 +181,17 @@ class _BetaChunkProcessor:
                         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(
                         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(
@@ -211,9 +221,10 @@ class _BetaChunkProcessor:
                     if self.accumulated_tool_json
                     else {}
                 )
-                yield ToolCallEndChunk()
+                yield ToolCallEndChunk(id=self.current_block_param["id"])
             elif block_type == "thinking":
-                yield ThoughtEndChunk()
+                if self.include_thoughts:
+                    yield ThoughtEndChunk()
             else:
                 raise NotImplementedError
 
@@ -249,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)
@@ -260,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):