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

mirascope/llm/prompts/prompts.py

@@ -0,0 +1,424 @@
+"""Concrete Prompt classes for generating messages with tools and formatting."""
+
+from dataclasses import dataclass
+from typing import Generic, overload
+
+from ..context import Context, DepsT
+from ..formatting import Format, FormattableT
+from ..models import Model
+from ..responses import (
+    AsyncContextResponse,
+    AsyncContextStreamResponse,
+    AsyncResponse,
+    AsyncStreamResponse,
+    ContextResponse,
+    ContextStreamResponse,
+    Response,
+    StreamResponse,
+)
+from ..tools import (
+    AsyncContextToolkit,
+    AsyncToolkit,
+    ContextToolkit,
+    Toolkit,
+)
+from ..types import P
+from . import _utils
+from .protocols import (
+    AsyncContextMessageTemplate,
+    AsyncMessageTemplate,
+    ContextMessageTemplate,
+    MessageTemplate,
+)
+
+
+@dataclass
+class Prompt(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
+    function becomes callable with a `Model` to generate LLM responses.
+
+    A `Prompt` is essentially: `MessageTemplate` + tools + format.
+    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
+    """The response format for the generated response."""
+
+    @overload
+    def __call__(
+        self: "Prompt[P, None]", model: Model, *args: P.args, **kwargs: P.kwargs
+    ) -> Response: ...
+
+    @overload
+    def __call__(
+        self: "Prompt[P, FormattableT]", model: Model, *args: P.args, **kwargs: P.kwargs
+    ) -> Response[FormattableT]: ...
+
+    def __call__(
+        self, model: Model, *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
+    ) -> Response: ...
+
+    @overload
+    def call(
+        self: "Prompt[P, FormattableT]", model: Model, *args: P.args, **kwargs: P.kwargs
+    ) -> Response[FormattableT]: ...
+
+    def call(
+        self, model: Model, *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)
+
+    @overload
+    def stream(
+        self: "Prompt[P, None]", model: Model, *args: P.args, **kwargs: P.kwargs
+    ) -> StreamResponse: ...
+
+    @overload
+    def stream(
+        self: "Prompt[P, FormattableT]", model: Model, *args: P.args, **kwargs: P.kwargs
+    ) -> StreamResponse[FormattableT]: ...
+
+    def stream(
+        self, model: Model, *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)
+
+
+@dataclass
+class AsyncPrompt(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
+    async function becomes callable with a `Model` to generate LLM responses asynchronously.
+
+    An `AsyncPrompt` is essentially: async `MessageTemplate` + tools + format.
+    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
+    """The response format for the generated response."""
+
+    @overload
+    async def __call__(
+        self: "AsyncPrompt[P, None]", model: Model, *args: P.args, **kwargs: P.kwargs
+    ) -> AsyncResponse: ...
+
+    @overload
+    async def __call__(
+        self: "AsyncPrompt[P, FormattableT]",
+        model: Model,
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> AsyncResponse[FormattableT]: ...
+
+    async def __call__(
+        self, model: Model, *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
+    ) -> AsyncResponse: ...
+
+    @overload
+    async def call(
+        self: "AsyncPrompt[P, FormattableT]",
+        model: Model,
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> AsyncResponse[FormattableT]: ...
+
+    async def call(
+        self, model: Model, *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
+        )
+
+    @overload
+    async def stream(
+        self: "AsyncPrompt[P, None]", model: Model, *args: P.args, **kwargs: P.kwargs
+    ) -> AsyncStreamResponse: ...
+
+    @overload
+    async def stream(
+        self: "AsyncPrompt[P, FormattableT]",
+        model: Model,
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> AsyncStreamResponse[FormattableT]: ...
+
+    async def stream(
+        self, model: Model, *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)
+        return await model.stream_async(
+            messages=messages, tools=self.toolkit, format=self.format
+        )
+
+
+@dataclass
+class ContextPrompt(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
+    function (with first parameter `'ctx'` of type `Context[DepsT]`) becomes callable
+    with a `Model` to generate LLM responses with context dependencies.
+
+    A `ContextPrompt` is essentially: `ContextMessageTemplate` + tools + format.
+    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
+    """The response format for the generated response."""
+
+    @overload
+    def __call__(
+        self: "ContextPrompt[P, DepsT, None]",
+        model: Model,
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> ContextResponse[DepsT, None]: ...
+
+    @overload
+    def __call__(
+        self: "ContextPrompt[P, DepsT, FormattableT]",
+        model: Model,
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> ContextResponse[DepsT, FormattableT]: ...
+
+    def __call__(
+        self,
+        model: Model,
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> ContextResponse[DepsT, None] | ContextResponse[DepsT, FormattableT]:
+        """Generates a response using the provided model."""
+        return self.call(model, ctx, *args, **kwargs)
+
+    @overload
+    def call(
+        self: "ContextPrompt[P, DepsT, None]",
+        model: Model,
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> ContextResponse[DepsT, None]: ...
+
+    @overload
+    def call(
+        self: "ContextPrompt[P, DepsT, FormattableT]",
+        model: Model,
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> ContextResponse[DepsT, FormattableT]: ...
+
+    def call(
+        self,
+        model: Model,
+        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)
+        return model.context_call(
+            ctx=ctx, messages=messages, tools=self.toolkit, format=self.format
+        )
+
+    @overload
+    def stream(
+        self: "ContextPrompt[P, DepsT, None]",
+        model: Model,
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> ContextStreamResponse[DepsT, None]: ...
+
+    @overload
+    def stream(
+        self: "ContextPrompt[P, DepsT, FormattableT]",
+        model: Model,
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> ContextStreamResponse[DepsT, FormattableT]: ...
+
+    def stream(
+        self,
+        model: Model,
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> (
+        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)
+        return model.context_stream(
+            ctx=ctx, messages=messages, tools=self.toolkit, format=self.format
+        )
+
+
+@dataclass
+class AsyncContextPrompt(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
+    async function (with first parameter `'ctx'` of type `Context[DepsT]`) becomes callable
+    with a `Model` to generate LLM responses asynchronously with context dependencies.
+
+    An `AsyncContextPrompt` is essentially: async `ContextMessageTemplate` + tools + format.
+    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
+    """The response format for the generated response."""
+
+    @overload
+    async def __call__(
+        self: "AsyncContextPrompt[P, DepsT, None]",
+        model: Model,
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> AsyncContextResponse[DepsT, None]: ...
+
+    @overload
+    async def __call__(
+        self: "AsyncContextPrompt[P, DepsT, FormattableT]",
+        model: Model,
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> AsyncContextResponse[DepsT, FormattableT]: ...
+
+    async def __call__(
+        self,
+        model: Model,
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> AsyncContextResponse[DepsT, None] | AsyncContextResponse[DepsT, FormattableT]:
+        """Generates a response using the provided model asynchronously."""
+        return await self.call(model, ctx, *args, **kwargs)
+
+    @overload
+    async def call(
+        self: "AsyncContextPrompt[P, DepsT, None]",
+        model: Model,
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> AsyncContextResponse[DepsT, None]: ...
+
+    @overload
+    async def call(
+        self: "AsyncContextPrompt[P, DepsT, FormattableT]",
+        model: Model,
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> AsyncContextResponse[DepsT, FormattableT]: ...
+
+    async def call(
+        self,
+        model: Model,
+        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)
+        return await model.context_call_async(
+            ctx=ctx, messages=messages, tools=self.toolkit, format=self.format
+        )
+
+    @overload
+    async def stream(
+        self: "AsyncContextPrompt[P, DepsT, None]",
+        model: Model,
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> AsyncContextStreamResponse[DepsT, None]: ...
+
+    @overload
+    async def stream(
+        self: "AsyncContextPrompt[P, DepsT, FormattableT]",
+        model: Model,
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> AsyncContextStreamResponse[DepsT, FormattableT]: ...
+
+    async def stream(
+        self,
+        model: Model,
+        ctx: Context[DepsT],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> (
+        AsyncContextStreamResponse[DepsT, None]
+        | 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)
+        return await model.context_stream_async(
+            ctx=ctx, messages=messages, tools=self.toolkit, format=self.format
+        )

mirascope/llm/prompts/protocols.py

@@ -1,69 +1,44 @@
 """Types for prompt functions."""
 
-from typing import Protocol, TypeVar
+from collections.abc import Sequence
+from typing import Protocol
 
 from ..context import Context, DepsT
 from ..messages import Message, UserContent
 from ..types import P
 
-PromptT = TypeVar(
-    "PromptT", bound="Prompt | AsyncPrompt | ContextPrompt | AsyncContextPrompt"
-)
-"""Type variable for prompt types.
 
-This type var represents a resolved prompt, i.e. one that returns a list of messages.
-"""
+class MessageTemplate(Protocol[P]):
+    """Protocol for a prompt function that returns `UserContent` or `Sequence[Message]`.
 
-
-class Prompt(Protocol[P]):
-    """Protocol for a `Prompt`, which returns `list[Message]`."""
-
-    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> list[Message]: ...
-
-
-class Promptable(Protocol[P]):
-    """Protocol for a `Promptable` that returns `UserContent` or `list[Message]`.
-
-    May be be converted by the `prompt` decorator into a `Prompt`.
+    A `MessageTemplate` is a raw function that returns prompt content. It can be
+    converted by the `llm.prompt` decorator into a `Prompt` (callable with a `Model`),
+    or by the `llm.call` decorator into a `Call` (`Prompt` + `Model`).
     """
 
     def __call__(
         self, *args: P.args, **kwargs: P.kwargs
-    ) -> UserContent | list[Message]: ...
-
+    ) -> UserContent | Sequence[Message]: ...
 
-class AsyncPrompt(Protocol[P]):
-    """Protocol for an `AsyncPrompt`, which returns `list[Message]`."""
 
-    async def __call__(self, *args: P.args, **kwargs: P.kwargs) -> list[Message]: ...
+class AsyncMessageTemplate(Protocol[P]):
+    """Protocol for an async prompt function that returns `UserContent` or `Sequence[Message]`.
 
-
-class AsyncPromptable(Protocol[P]):
-    """Protocol for an `AsyncPromptable` that returns `UserContent` or `list[Message]`.
-
-    May be converted by the `prompt` decorator into an `AsyncPrompt`.
+    An async `MessageTemplate` that can be converted by the `llm.prompt` decorator
+    into an `AsyncPrompt`, or by the `llm.call` decorator into an `AsyncCall`.
     """
 
     async def __call__(
         self, *args: P.args, **kwargs: P.kwargs
-    ) -> UserContent | list[Message]: ...
-
-
-class ContextPrompt(Protocol[P, DepsT]):
-    """Protocol for a `ContextPrompt`, which returns `list[Message]`."""
-
-    def __call__(
-        self,
-        ctx: Context[DepsT],
-        *args: P.args,
-        **kwargs: P.kwargs,
-    ) -> list[Message]: ...
+    ) -> UserContent | Sequence[Message]: ...
 
 
-class ContextPromptable(Protocol[P, DepsT]):
-    """Protocol for a `ContextPromptable` that returns `UserContent` or `list[Message]`.
+class ContextMessageTemplate(Protocol[P, DepsT]):
+    """Protocol for a context-aware prompt function that returns `UserContent` or `Sequence[Message]`.
 
-    May be converted by the `prompt` decorator into a `ContextPrompt`.
+    A `MessageTemplate` with a first parameter named `'ctx'` of type `Context[DepsT]`.
+    Can be converted by the `llm.prompt` decorator into a `ContextPrompt`, or by
+    the `llm.call` decorator into a `ContextCall`.
     """
 
     def __call__(
@@ -71,24 +46,15 @@ class ContextPromptable(Protocol[P, DepsT]):
         ctx: Context[DepsT],
         *args: P.args,
         **kwargs: P.kwargs,
-    ) -> UserContent | list[Message]: ...
-
-
-class AsyncContextPrompt(Protocol[P, DepsT]):
-    """Protocol for an `AsyncContextPrompt`, which returns `list[Message]`."""
-
-    async def __call__(
-        self,
-        ctx: Context[DepsT],
-        *args: P.args,
-        **kwargs: P.kwargs,
-    ) -> list[Message]: ...
+    ) -> UserContent | Sequence[Message]: ...
 
 
-class AsyncContextPromptable(Protocol[P, DepsT]):
-    """Protocol for an `AsyncContextPromptable` that returns `UserContent` or `list[Message]`.
+class AsyncContextMessageTemplate(Protocol[P, DepsT]):
+    """Protocol for an async context-aware prompt function that returns `UserContent` or `Sequence[Message]`.
 
-    May be converted by the `prompt` decorator into an `AsyncContextPrompt`.
+    An async `MessageTemplate` with a first parameter named `'ctx'` of type `Context[DepsT]`.
+    Can be converted by the `llm.prompt` decorator into an `AsyncContextPrompt`, or by
+    the `llm.call` decorator into an `AsyncContextCall`.
     """
 
     async def __call__(
@@ -96,4 +62,4 @@ class AsyncContextPromptable(Protocol[P, DepsT]):
         ctx: Context[DepsT],
         *args: P.args,
         **kwargs: P.kwargs,
-    ) -> UserContent | list[Message]: ...
+    ) -> UserContent | Sequence[Message]: ...

mirascope/llm/providers/__init__.py

@@ -0,0 +1,38 @@
+"""Interfaces for LLM providers."""
+
+from .anthropic import (
+    AnthropicModelId,
+    AnthropicProvider,
+)
+from .base import BaseProvider, Params, Provider
+from .google import GoogleModelId, GoogleProvider
+from .load_provider import load, load_provider
+from .mlx import MLXModelId, MLXProvider
+from .model_id import ModelId
+from .openai import (
+    OpenAIModelId,
+    OpenAIProvider,
+)
+from .provider_id import KNOWN_PROVIDER_IDS, ProviderId
+from .provider_registry import get_provider_for_model, register_provider
+
+__all__ = [
+    "KNOWN_PROVIDER_IDS",
+    "AnthropicModelId",
+    "AnthropicProvider",
+    "BaseProvider",
+    "GoogleModelId",
+    "GoogleProvider",
+    "MLXModelId",
+    "MLXProvider",
+    "ModelId",
+    "OpenAIModelId",
+    "OpenAIProvider",
+    "Params",
+    "Provider",
+    "ProviderId",
+    "get_provider_for_model",
+    "load",
+    "load_provider",
+    "register_provider",
+]

mirascope/llm/{clients → providers}/_missing_import_stubs.py

@@ -5,12 +5,12 @@ from collections.abc import Callable
 
 def create_import_error_stub(
     package_name: str, client_name: str
-) -> Callable:  # pragma: no cover
+) -> Callable[..., None]:  # pragma: no cover
     """Create a stub that raises ImportError when called.
 
     Args:
         package_name: The package/extra name (e.g., "anthropic", "openai", "google")
-        client_name: The client name for the error message (e.g., "AnthropicClient")
+        client_name: The client name for the error message (e.g., "AnthropicProvider")
 
     Returns:
         A callable that raises `ImportError` with helpful message.
@@ -26,17 +26,19 @@ def create_import_error_stub(
     return _raise_not_installed
 
 
-def create_client_stub(package_name: str, client_name: str) -> type:  # pragma: no cover
-    """Create a stub client class that raises ImportError when instantiated.
+def create_provider_stub(
+    package_name: str, provider_name: str
+) -> type:  # pragma: no cover
+    """Create a stub provider class that raises ImportError when instantiated.
 
     Args:
         package_name: The package/extra name (e.g., "anthropic", "openai", "google")
-        client_name: The client name for the error message (e.g., "AnthropicClient")
+        provider_name: The client name for the error message (e.g., "AnthropicProvider")
 
     Returns:
         A stub class that raises `ImportError` on instantiation.
     """
-    error_fn = create_import_error_stub(package_name, client_name)
+    error_fn = create_import_error_stub(package_name, provider_name)
 
     class _ClientStub:
         """Stub client that raises `ImportError` when instantiated."""

mirascope/llm/providers/anthropic/__init__.py

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

mirascope/llm/{clients → providers}/anthropic/_utils/decode.py

@@ -30,7 +30,7 @@ from ....responses import (
     RawMessageChunk,
     RawStreamEventChunk,
 )
-from ..model_ids import AnthropicModelId
+from ..model_id import AnthropicModelId, model_name
 
 ANTHROPIC_FINISH_REASON_MAP = {
     "max_tokens": FinishReason.MAX_TOKENS,
@@ -65,8 +65,9 @@ def decode_response(
     """Convert Anthropic message to mirascope AssistantMessage."""
     assistant_message = AssistantMessage(
         content=[_decode_assistant_content(part) for part in response.content],
-        provider="anthropic",
+        provider_id="anthropic",
         model_id=model_id,
+        provider_model_name=model_name(model_id),
         raw_message={
             "role": response.role,
             "content": [part.model_dump() for part in response.content],
@@ -227,7 +228,7 @@ def decode_stream(
     """Returns a ChunkIterator converted from an Anthropic MessageStreamManager"""
     processor = _AnthropicChunkProcessor()
     with anthropic_stream_manager as stream:
-        for event in stream._raw_stream:
+        for event in stream._raw_stream:  # pyright: ignore[reportPrivateUsage]
             yield from processor.process_event(event)
     yield processor.raw_message_chunk()
 
@@ -238,7 +239,7 @@ async def decode_async_stream(
     """Returns an AsyncChunkIterator converted from an Anthropic MessageStreamManager"""
     processor = _AnthropicChunkProcessor()
     async with anthropic_stream_manager as stream:
-        async for event in stream._raw_stream:
+        async for event in stream._raw_stream:  # pyright: ignore[reportPrivateUsage]
             for item in processor.process_event(event):
                 yield item
     yield processor.raw_message_chunk()