anthropic 0.72.1__py3-none-any.whl → 0.73.0__py3-none-any.whl

anthropic/__init__.py

@@ -44,6 +44,7 @@ from ._exceptions import (
 )
 from ._base_client import DefaultHttpxClient, DefaultAioHttpClient, DefaultAsyncHttpxClient
 from ._utils._logs import setup_logging as _setup_logging
+from .lib._parse._transform import transform_schema
 
 __all__ = [
     "types",
@@ -91,6 +92,7 @@ __all__ = [
     "AI_PROMPT",
     "beta_tool",
     "beta_async_tool",
+    "transform_schema",
 ]
 
 if not _t.TYPE_CHECKING:

anthropic/_compat.py

@@ -131,6 +131,12 @@ def model_json(model: pydantic.BaseModel, *, indent: int | None = None) -> str:
     return model.model_dump_json(indent=indent)
 
 
+def model_parse_json(model: type[_ModelT], data: str | bytes) -> _ModelT:
+    if PYDANTIC_V1:
+        return model.parse_raw(data)  # pyright: ignore[reportDeprecated]
+    return model.model_validate_json(data)
+
+
 def model_dump(
     model: pydantic.BaseModel,
     *,

anthropic/_models.py

@@ -774,7 +774,7 @@ else:
 
 
 if not PYDANTIC_V1:
-    from pydantic import TypeAdapter as _TypeAdapter
+    from pydantic import TypeAdapter as _TypeAdapter, computed_field as computed_field
 
     _CachedTypeAdapter = cast("TypeAdapter[object]", lru_cache(maxsize=None)(_TypeAdapter))
 
@@ -811,6 +811,18 @@ elif not TYPE_CHECKING:  # TODO: condition is weird
     def TypeAdapter(*_args: Any, **_kwargs: Any) -> Any:
         raise RuntimeError("attempted to use TypeAdapter in pydantic v1")
 
+    def computed_field(func: Any | None = None, /, **__: Any) -> Any:
+        def _exc_func(*_: Any, **__: Any) -> Any:
+            raise RuntimeError("attempted to use computed_field in pydantic v1")
+
+        def _dec(*_: Any, **__: Any) -> Any:
+            return _exc_func
+
+        if func is not None:
+            return _dec(func)
+        else:
+            return _dec
+
 
 class FinalRequestOptionsInput(TypedDict, total=False):
     method: Required[str]

anthropic/_utils/_transform.py

@@ -218,7 +218,7 @@ def _transform_recursive(
         return data
 
     if isinstance(data, pydantic.BaseModel):
-        return model_dump(data, exclude_unset=True, mode="json")
+        return model_dump(data, exclude_unset=True, mode="json", exclude=getattr(data, "__api_exclude__", None))
 
     annotated_type = _get_annotated_type(annotation)
     if annotated_type is None:

anthropic/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "anthropic"
-__version__ = "0.72.1"  # x-release-please-version
+__version__ = "0.73.0"  # x-release-please-version

anthropic/lib/_parse/_response.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from typing_extensions import TypeVar
+
+from ..._types import NotGiven
+from ..._models import TypeAdapter, construct_type_unchecked
+from ..._utils._utils import is_given
+from ...types.beta.beta_message import BetaMessage
+from ...types.beta.parsed_beta_message import ParsedBetaMessage, ParsedBetaTextBlock, ParsedBetaContentBlock
+
+ResponseFormatT = TypeVar("ResponseFormatT", default=None)
+
+
+def parse_text(text: str, output_format: ResponseFormatT | NotGiven) -> ResponseFormatT | None:
+    if is_given(output_format):
+        adapted_type: TypeAdapter[ResponseFormatT] = TypeAdapter(output_format)
+        return adapted_type.validate_json(text)
+    return None
+
+
+def parse_response(
+    *,
+    output_format: ResponseFormatT | NotGiven,
+    response: BetaMessage,
+) -> ParsedBetaMessage[ResponseFormatT]:
+    content_list: list[ParsedBetaContentBlock[ResponseFormatT]] = []
+    for content in response.content:
+        if content.type == "text":
+            content_list.append(
+                construct_type_unchecked(
+                    type_=ParsedBetaTextBlock[ResponseFormatT],
+                    value={**content.to_dict(), "parsed_output": parse_text(content.text, output_format)},
+                )
+            )
+        else:
+            content_list.append(content)  # type: ignore
+
+    return construct_type_unchecked(
+        type_=ParsedBetaMessage[ResponseFormatT],
+        value={
+            **response.to_dict(),
+            "content": content_list,
+        },
+    )

anthropic/lib/_parse/_transform.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+import inspect
+from typing import Any, Literal, Optional, cast
+from typing_extensions import assert_never
+
+import pydantic
+
+from ..._utils import is_list
+
+SupportedTypes = Literal[
+    "object",
+    "array",
+    "string",
+    "integer",
+    "number",
+    "boolean",
+    "null",
+]
+
+SupportedStringFormats = {
+    "date-time",
+    "time",
+    "date",
+    "duration",
+    "email",
+    "hostname",
+    "uri",
+    "ipv4",
+    "ipv6",
+    "uuid",
+}
+
+
+def get_transformed_string(
+    schema: dict[str, Any],
+) -> dict[str, Any]:
+    """Transforms a JSON schema of type string to ensure it conforms to the API's expectations.
+
+    Specifically, it ensures that if the schema is of type "string" and does not already
+    specify a "format", it sets the format to "text".
+
+    Args:
+        schema: The original JSON schema.
+
+    Returns:
+        The transformed JSON schema.
+    """
+    if schema.get("type") == "string" and "format" not in schema:
+        schema["format"] = "text"
+    return schema
+
+
+def transform_schema(
+    json_schema: type[pydantic.BaseModel] | dict[str, Any],
+) -> dict[str, Any]:
+    """
+    Transforms a JSON schema to ensure it conforms to the API's expectations.
+
+    Args:
+        json_schema (Dict[str, Any]): The original JSON schema.
+
+    Returns:
+        The transformed JSON schema.
+
+    Examples:
+        >>> transform_schema(
+        ...     {
+        ...         "type": "integer",
+        ...         "minimum": 1,
+        ...         "maximum": 10,
+        ...         "description": "A number",
+        ...     }
+        ... )
+        {'type': 'integer', 'description': 'A number\n\n{minimum: 1, maximum: 10}'}
+    """
+    if inspect.isclass(json_schema) and issubclass(json_schema, pydantic.BaseModel):  # pyright: ignore[reportUnnecessaryIsInstance]
+        json_schema = json_schema.model_json_schema()
+
+    strict_schema: dict[str, Any] = {}
+    json_schema = {**json_schema}
+
+    ref = json_schema.pop("$ref", None)
+    if ref is not None:
+        strict_schema["$ref"] = ref
+        return strict_schema
+
+    defs = json_schema.pop("$defs", None)
+    if defs is not None:
+        strict_defs: dict[str, Any] = {}
+        strict_schema["$defs"] = strict_defs
+
+        for name, schema in defs.items():
+            strict_defs[name] = transform_schema(schema)
+
+    type_: Optional[SupportedTypes] = json_schema.pop("type", None)
+    any_of = json_schema.pop("anyOf", None)
+    one_of = json_schema.pop("oneOf", None)
+    all_of = json_schema.pop("allOf", None)
+
+    if is_list(any_of):
+        strict_schema["anyOf"] = [transform_schema(cast("dict[str, Any]", variant)) for variant in any_of]
+    elif is_list(one_of):
+        strict_schema["anyOf"] = [transform_schema(cast("dict[str, Any]", variant)) for variant in one_of]
+    elif is_list(all_of):
+        strict_schema["allOf"] = [transform_schema(cast("dict[str, Any]", variant)) for variant in all_of]
+    else:
+        if type_ is None:
+            raise ValueError("Schema must have a 'type', 'anyOf', 'oneOf', or 'allOf' field.")
+
+        strict_schema["type"] = type_
+
+    description = json_schema.pop("description", None)
+    if description is not None:
+        strict_schema["description"] = description
+
+    title = json_schema.pop("title", None)
+    if title is not None:
+        strict_schema["title"] = title
+
+    if type_ == "object":
+        strict_schema["properties"] = {
+            key: transform_schema(prop_schema) for key, prop_schema in json_schema.pop("properties", {}).items()
+        }
+        json_schema.pop("additionalProperties", None)
+        strict_schema["additionalProperties"] = False
+
+        required = json_schema.pop("required", None)
+        if required is not None:
+            strict_schema["required"] = required
+
+    elif type_ == "string":
+        format = json_schema.pop("format", None)
+        if format and format in SupportedStringFormats:
+            strict_schema["format"] = format
+        elif format:
+            # add it back so its treated as an extra property and appended to the description
+            json_schema["format"] = format
+    elif type_ == "array":
+        items = json_schema.pop("items", None)
+        if items is not None:
+            strict_schema["items"] = transform_schema(items)
+
+        min_items = json_schema.pop("minItems", None)
+        if min_items is not None and min_items == 0 or min_items == 1:
+            strict_schema["minItems"] = min_items
+        elif min_items is not None:
+            # add it back so its treated as an extra property and appended to the description
+            json_schema["minItems"] = min_items
+
+    elif type_ == "boolean" or type_ == "integer" or type_ == "number" or type_ == "null" or type_ is None:
+        pass
+    else:
+        assert_never(type_)
+
+    # if there are any propes leftover then they aren't supported, so we add them to the description
+    # so that the model *might* follow them.
+    if json_schema:
+        description = strict_schema.get("description")
+        strict_schema["description"] = (
+            (description + "\n\n" if description is not None else "")
+            + "{"
+            + ", ".join(f"{key}: {value}" for key, value in json_schema.items())
+            + "}"
+        )
+
+    return strict_schema

anthropic/lib/streaming/__init__.py

@@ -1,3 +1,5 @@
+from typing_extensions import TypeAlias
+
 from ._types import (
     TextEvent as TextEvent,
     InputJsonEvent as InputJsonEvent,
@@ -12,12 +14,20 @@ from ._messages import (
     AsyncMessageStreamManager as AsyncMessageStreamManager,
 )
 from ._beta_types import (
-    BetaTextEvent as BetaTextEvent,
     BetaInputJsonEvent as BetaInputJsonEvent,
-    BetaMessageStopEvent as BetaMessageStopEvent,
-    BetaMessageStreamEvent as BetaMessageStreamEvent,
-    BetaContentBlockStopEvent as BetaContentBlockStopEvent,
+    ParsedBetaTextEvent as ParsedBetaTextEvent,
+    ParsedBetaMessageStopEvent as ParsedBetaMessageStopEvent,
+    ParsedBetaMessageStreamEvent as ParsedBetaMessageStreamEvent,
+    ParsedBetaContentBlockStopEvent as ParsedBetaContentBlockStopEvent,
 )
+
+# For backwards compatibility
+BetaTextEvent: TypeAlias = ParsedBetaTextEvent
+BetaMessageStopEvent: TypeAlias = ParsedBetaMessageStopEvent[object]
+BetaMessageStreamEvent: TypeAlias = ParsedBetaMessageStreamEvent
+BetaContentBlockStopEvent: TypeAlias = ParsedBetaContentBlockStopEvent[object]
+
+
 from ._beta_messages import (
     BetaMessageStream as BetaMessageStream,
     BetaAsyncMessageStream as BetaAsyncMessageStream,

anthropic/lib/streaming/_beta_messages.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+import builtins
 from types import TracebackType
-from typing import TYPE_CHECKING, Any, Type, Callable, cast
+from typing import TYPE_CHECKING, Any, Type, Generic, Callable, cast
 from typing_extensions import Self, Iterator, Awaitable, AsyncIterator, assert_never
 
 import httpx
@@ -11,23 +12,27 @@ from anthropic.types.beta.beta_tool_use_block import BetaToolUseBlock
 from anthropic.types.beta.beta_mcp_tool_use_block import BetaMCPToolUseBlock
 from anthropic.types.beta.beta_server_tool_use_block import BetaServerToolUseBlock
 
+from ..._types import NOT_GIVEN, NotGiven
 from ..._utils import consume_sync_iterator, consume_async_iterator
 from ..._models import build, construct_type, construct_type_unchecked
 from ._beta_types import (
-    BetaTextEvent,
     BetaCitationEvent,
     BetaThinkingEvent,
     BetaInputJsonEvent,
     BetaSignatureEvent,
-    BetaMessageStopEvent,
-    BetaMessageStreamEvent,
-    BetaContentBlockStopEvent,
+    ParsedBetaTextEvent,
+    ParsedBetaMessageStopEvent,
+    ParsedBetaMessageStreamEvent,
+    ParsedBetaContentBlockStopEvent,
 )
 from ..._streaming import Stream, AsyncStream
-from ...types.beta import BetaMessage, BetaContentBlock, BetaRawMessageStreamEvent
+from ...types.beta import BetaRawMessageStreamEvent
+from ..._utils._utils import is_given
+from .._parse._response import ResponseFormatT, parse_text
+from ...types.beta.parsed_beta_message import ParsedBetaMessage, ParsedBetaContentBlock
 
 
-class BetaMessageStream:
+class BetaMessageStream(Generic[ResponseFormatT]):
     text_stream: Iterator[str]
     """Iterator over just the text deltas in the stream.
 
@@ -38,11 +43,16 @@ class BetaMessageStream:
     ```
     """
 
-    def __init__(self, raw_stream: Stream[BetaRawMessageStreamEvent]) -> None:
+    def __init__(
+        self,
+        raw_stream: Stream[BetaRawMessageStreamEvent],
+        output_format: ResponseFormatT | NotGiven,
+    ) -> None:
         self._raw_stream = raw_stream
         self.text_stream = self.__stream_text__()
         self._iterator = self.__stream__()
-        self.__final_message_snapshot: BetaMessage | None = None
+        self.__final_message_snapshot: ParsedBetaMessage[ResponseFormatT] | None = None
+        self.__output_format = output_format
 
     @property
     def response(self) -> httpx.Response:
@@ -52,10 +62,10 @@ class BetaMessageStream:
     def request_id(self) -> str | None:
         return self.response.headers.get("request-id")  # type: ignore[no-any-return]
 
-    def __next__(self) -> BetaMessageStreamEvent:
+    def __next__(self) -> ParsedBetaMessageStreamEvent[ResponseFormatT]:
         return self._iterator.__next__()
 
-    def __iter__(self) -> Iterator[BetaMessageStreamEvent]:
+    def __iter__(self) -> Iterator[ParsedBetaMessageStreamEvent[ResponseFormatT]]:
         for item in self._iterator:
             yield item
 
@@ -78,7 +88,7 @@ class BetaMessageStream:
         """
         self._raw_stream.close()
 
-    def get_final_message(self) -> BetaMessage:
+    def get_final_message(self) -> ParsedBetaMessage[ResponseFormatT]:
         """Waits until the stream has been read to completion and returns
         the accumulated `Message` object.
         """
@@ -113,16 +123,17 @@ class BetaMessageStream:
 
     # properties
     @property
-    def current_message_snapshot(self) -> BetaMessage:
+    def current_message_snapshot(self) -> ParsedBetaMessage[ResponseFormatT]:
         assert self.__final_message_snapshot is not None
         return self.__final_message_snapshot
 
-    def __stream__(self) -> Iterator[BetaMessageStreamEvent]:
+    def __stream__(self) -> Iterator[ParsedBetaMessageStreamEvent[ResponseFormatT]]:
         for sse_event in self._raw_stream:
             self.__final_message_snapshot = accumulate_event(
                 event=sse_event,
                 current_snapshot=self.__final_message_snapshot,
                 request_headers=self.response.request.headers,
+                output_format=self.__output_format,
             )
 
             events_to_fire = build_events(event=sse_event, message_snapshot=self.current_message_snapshot)
@@ -135,7 +146,7 @@ class BetaMessageStream:
                 yield chunk.delta.text
 
 
-class BetaMessageStreamManager:
+class BetaMessageStreamManager(Generic[ResponseFormatT]):
     """Wrapper over MessageStream that is returned by `.stream()`.
 
     ```py
@@ -148,13 +159,16 @@ class BetaMessageStreamManager:
     def __init__(
         self,
         api_request: Callable[[], Stream[BetaRawMessageStreamEvent]],
+        *,
+        output_format: ResponseFormatT | NotGiven,
     ) -> None:
-        self.__stream: BetaMessageStream | None = None
+        self.__stream: BetaMessageStream[ResponseFormatT] | None = None
         self.__api_request = api_request
+        self.__output_format = output_format
 
-    def __enter__(self) -> BetaMessageStream:
+    def __enter__(self) -> BetaMessageStream[ResponseFormatT]:
         raw_stream = self.__api_request()
-        self.__stream = BetaMessageStream(raw_stream)
+        self.__stream = BetaMessageStream(raw_stream, output_format=self.__output_format)
         return self.__stream
 
     def __exit__(
@@ -167,7 +181,7 @@ class BetaMessageStreamManager:
             self.__stream.close()
 
 
-class BetaAsyncMessageStream:
+class BetaAsyncMessageStream(Generic[ResponseFormatT]):
     text_stream: AsyncIterator[str]
     """Async iterator over just the text deltas in the stream.
 
@@ -178,11 +192,16 @@ class BetaAsyncMessageStream:
     ```
     """
 
-    def __init__(self, raw_stream: AsyncStream[BetaRawMessageStreamEvent]) -> None:
+    def __init__(
+        self,
+        raw_stream: AsyncStream[BetaRawMessageStreamEvent],
+        output_format: ResponseFormatT | NotGiven,
+    ) -> None:
         self._raw_stream = raw_stream
         self.text_stream = self.__stream_text__()
         self._iterator = self.__stream__()
-        self.__final_message_snapshot: BetaMessage | None = None
+        self.__final_message_snapshot: ParsedBetaMessage[ResponseFormatT] | None = None
+        self.__output_format = output_format
 
     @property
     def response(self) -> httpx.Response:
@@ -192,10 +211,10 @@ class BetaAsyncMessageStream:
     def request_id(self) -> str | None:
         return self.response.headers.get("request-id")  # type: ignore[no-any-return]
 
-    async def __anext__(self) -> BetaMessageStreamEvent:
+    async def __anext__(self) -> ParsedBetaMessageStreamEvent[ResponseFormatT]:
         return await self._iterator.__anext__()
 
-    async def __aiter__(self) -> AsyncIterator[BetaMessageStreamEvent]:
+    async def __aiter__(self) -> AsyncIterator[ParsedBetaMessageStreamEvent[ResponseFormatT]]:
         async for item in self._iterator:
             yield item
 
@@ -218,7 +237,7 @@ class BetaAsyncMessageStream:
         """
         await self._raw_stream.close()
 
-    async def get_final_message(self) -> BetaMessage:
+    async def get_final_message(self) -> ParsedBetaMessage[ResponseFormatT]:
         """Waits until the stream has been read to completion and returns
         the accumulated `Message` object.
         """
@@ -253,16 +272,17 @@ class BetaAsyncMessageStream:
 
     # properties
     @property
-    def current_message_snapshot(self) -> BetaMessage:
+    def current_message_snapshot(self) -> ParsedBetaMessage[ResponseFormatT]:
         assert self.__final_message_snapshot is not None
         return self.__final_message_snapshot
 
-    async def __stream__(self) -> AsyncIterator[BetaMessageStreamEvent]:
+    async def __stream__(self) -> AsyncIterator[ParsedBetaMessageStreamEvent[ResponseFormatT]]:
         async for sse_event in self._raw_stream:
             self.__final_message_snapshot = accumulate_event(
                 event=sse_event,
                 current_snapshot=self.__final_message_snapshot,
                 request_headers=self.response.request.headers,
+                output_format=self.__output_format,
             )
 
             events_to_fire = build_events(event=sse_event, message_snapshot=self.current_message_snapshot)
@@ -275,7 +295,7 @@ class BetaAsyncMessageStream:
                 yield chunk.delta.text
 
 
-class BetaAsyncMessageStreamManager:
+class BetaAsyncMessageStreamManager(Generic[ResponseFormatT]):
     """Wrapper over BetaAsyncMessageStream that is returned by `.stream()`
     so that an async context manager can be used without `await`ing the
     original client call.
@@ -290,13 +310,16 @@ class BetaAsyncMessageStreamManager:
     def __init__(
         self,
         api_request: Awaitable[AsyncStream[BetaRawMessageStreamEvent]],
+        *,
+        output_format: ResponseFormatT | NotGiven = NOT_GIVEN,
     ) -> None:
-        self.__stream: BetaAsyncMessageStream | None = None
+        self.__stream: BetaAsyncMessageStream[ResponseFormatT] | None = None
         self.__api_request = api_request
+        self.__output_format = output_format
 
-    async def __aenter__(self) -> BetaAsyncMessageStream:
+    async def __aenter__(self) -> BetaAsyncMessageStream[ResponseFormatT]:
         raw_stream = await self.__api_request
-        self.__stream = BetaAsyncMessageStream(raw_stream)
+        self.__stream = BetaAsyncMessageStream(raw_stream, output_format=self.__output_format)
         return self.__stream
 
     async def __aexit__(
@@ -312,16 +335,18 @@ class BetaAsyncMessageStreamManager:
 def build_events(
     *,
     event: BetaRawMessageStreamEvent,
-    message_snapshot: BetaMessage,
-) -> list[BetaMessageStreamEvent]:
-    events_to_fire: list[BetaMessageStreamEvent] = []
+    message_snapshot: ParsedBetaMessage[ResponseFormatT],
+) -> list[ParsedBetaMessageStreamEvent[ResponseFormatT]]:
+    events_to_fire: list[ParsedBetaMessageStreamEvent[ResponseFormatT]] = []
 
     if event.type == "message_start":
         events_to_fire.append(event)
     elif event.type == "message_delta":
         events_to_fire.append(event)
     elif event.type == "message_stop":
-        events_to_fire.append(build(BetaMessageStopEvent, type="message_stop", message=message_snapshot))
+        events_to_fire.append(
+            build(ParsedBetaMessageStopEvent[ResponseFormatT], type="message_stop", message=message_snapshot)
+        )
     elif event.type == "content_block_start":
         events_to_fire.append(event)
     elif event.type == "content_block_delta":
@@ -332,7 +357,7 @@ def build_events(
             if content_block.type == "text":
                 events_to_fire.append(
                     build(
-                        BetaTextEvent,
+                        ParsedBetaTextEvent,
                         type="text",
                         text=event.delta.text,
                         snapshot=content_block.text,
@@ -385,9 +410,14 @@ def build_events(
     elif event.type == "content_block_stop":
         content_block = message_snapshot.content[event.index]
 
-        events_to_fire.append(
-            build(BetaContentBlockStopEvent, type="content_block_stop", index=event.index, content_block=content_block),
+        event_to_fire = build(
+            ParsedBetaContentBlockStopEvent,
+            type="content_block_stop",
+            index=event.index,
+            content_block=content_block,
         )
+
+        events_to_fire.append(event_to_fire)
     else:
         # we only want exhaustive checking for linters, not at runtime
         if TYPE_CHECKING:  # type: ignore[unreachable]
@@ -408,9 +438,10 @@ TRACKS_TOOL_INPUT = (
 def accumulate_event(
     *,
     event: BetaRawMessageStreamEvent,
-    current_snapshot: BetaMessage | None,
+    current_snapshot: ParsedBetaMessage[ResponseFormatT] | None,
     request_headers: httpx.Headers,
-) -> BetaMessage:
+    output_format: ResponseFormatT | NotGiven = NOT_GIVEN,
+) -> ParsedBetaMessage[ResponseFormatT]:
     if not isinstance(cast(Any, event), BaseModel):
         event = cast(  # pyright: ignore[reportUnnecessaryCast]
             BetaRawMessageStreamEvent,
@@ -420,11 +451,15 @@ def accumulate_event(
             ),
         )
         if not isinstance(cast(Any, event), BaseModel):
-            raise TypeError(f"Unexpected event runtime type, after deserialising twice - {event} - {type(event)}")
+            raise TypeError(
+                f"Unexpected event runtime type, after deserialising twice - {event} - {builtins.type(event)}"
+            )
 
     if current_snapshot is None:
         if event.type == "message_start":
-            return BetaMessage.construct(**cast(Any, event.message.to_dict()))
+            return cast(
+                ParsedBetaMessage[ResponseFormatT], ParsedBetaMessage.construct(**cast(Any, event.message.to_dict()))
+            )
 
         raise RuntimeError(f'Unexpected event order, got {event.type} before "message_start"')
 
@@ -432,8 +467,8 @@ def accumulate_event(
         # TODO: check index
         current_snapshot.content.append(
             cast(
-                BetaContentBlock,
-                construct_type(type_=BetaContentBlock, value=event.content_block.model_dump()),
+                Any,  # Pydantic does not support generic unions at runtime
+                construct_type(type_=ParsedBetaContentBlock, value=event.content_block.model_dump()),
             ),
         )
     elif event.type == "content_block_delta":
@@ -481,6 +516,10 @@ def accumulate_event(
             # we only want exhaustive checking for linters, not at runtime
             if TYPE_CHECKING:  # type: ignore[unreachable]
                 assert_never(event.delta)
+    elif event.type == "content_block_stop":
+        content_block = current_snapshot.content[event.index]
+        if content_block.type == "text" and is_given(output_format):
+            content_block.parsed_output = parse_text(content_block.text, output_format)
     elif event.type == "message_delta":
         current_snapshot.container = event.delta.container
         current_snapshot.stop_reason = event.delta.stop_reason