anthropic 0.76.0__py3-none-any.whl → 0.77.1__py3-none-any.whl

anthropic/_base_client.py

@@ -89,6 +89,7 @@ from ._exceptions import (
     APIConnectionError,
     APIResponseValidationError,
 )
+from ._utils._json import openapi_dumps
 from ._utils._httpx import get_environment_proxies
 from ._legacy_response import LegacyAPIResponse
 
@@ -567,8 +568,10 @@ class BaseClient(Generic[_HttpxClientT, _DefaultStreamT]):
                 kwargs["content"] = options.content
             elif isinstance(json_data, bytes):
                 kwargs["content"] = json_data
-            else:
-                kwargs["json"] = json_data if is_given(json_data) else None
+            elif not files:
+                # Don't set content when JSON is sent as multipart/form-data,
+                # since httpx's content param overrides other body arguments
+                kwargs["content"] = openapi_dumps(json_data) if is_given(json_data) and json_data is not None else None
             kwargs["files"] = files
         else:
             headers.pop("Content-Type", None)

anthropic/_compat.py

@@ -145,6 +145,7 @@ def model_dump(
     exclude_defaults: bool = False,
     warnings: bool = True,
     mode: Literal["json", "python"] = "python",
+    by_alias: bool | None = None,
 ) -> dict[str, Any]:
     if (not PYDANTIC_V1) or hasattr(model, "model_dump"):
         return model.model_dump(
@@ -154,13 +155,12 @@ def model_dump(
             exclude_defaults=exclude_defaults,
             # warnings are not supported in Pydantic v1
             warnings=True if PYDANTIC_V1 else warnings,
+            by_alias=by_alias,
         )
     return cast(
         "dict[str, Any]",
         model.dict(  # pyright: ignore[reportDeprecated, reportUnnecessaryCast]
-            exclude=exclude,
-            exclude_unset=exclude_unset,
-            exclude_defaults=exclude_defaults,
+            exclude=exclude, exclude_unset=exclude_unset, exclude_defaults=exclude_defaults, by_alias=bool(by_alias)
         ),
     )
 

anthropic/_utils/_json.py

@@ -0,0 +1,35 @@
+import json
+from typing import Any
+from datetime import datetime
+from typing_extensions import override
+
+import pydantic
+
+from .._compat import model_dump
+
+
+def openapi_dumps(obj: Any) -> bytes:
+    """
+    Serialize an object to UTF-8 encoded JSON bytes.
+
+    Extends the standard json.dumps with support for additional types
+    commonly used in the SDK, such as `datetime`, `pydantic.BaseModel`, etc.
+    """
+    return json.dumps(
+        obj,
+        cls=_CustomEncoder,
+        # Uses the same defaults as httpx's JSON serialization
+        ensure_ascii=False,
+        separators=(",", ":"),
+        allow_nan=False,
+    ).encode()
+
+
+class _CustomEncoder(json.JSONEncoder):
+    @override
+    def default(self, o: Any) -> Any:
+        if isinstance(o, datetime):
+            return o.isoformat()
+        if isinstance(o, pydantic.BaseModel):
+            return model_dump(o, exclude_unset=True, mode="json", by_alias=True)
+        return super().default(o)

anthropic/_version.py

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

anthropic/lib/_parse/_response.py

@@ -5,6 +5,8 @@ from typing_extensions import TypeVar
 from ..._types import NotGiven
 from ..._models import TypeAdapter, construct_type_unchecked
 from ..._utils._utils import is_given
+from ...types.message import Message
+from ...types.parsed_message import ParsedMessage, ParsedTextBlock, ParsedContentBlock
 from ...types.beta.beta_message import BetaMessage
 from ...types.beta.parsed_beta_message import ParsedBetaMessage, ParsedBetaTextBlock, ParsedBetaContentBlock
 
@@ -18,7 +20,7 @@ def parse_text(text: str, output_format: ResponseFormatT | NotGiven) -> Response
     return None
 
 
-def parse_response(
+def parse_beta_response(
     *,
     output_format: ResponseFormatT | NotGiven,
     response: BetaMessage,
@@ -42,3 +44,29 @@ def parse_response(
             "content": content_list,
         },
     )
+
+
+def parse_response(
+    *,
+    output_format: ResponseFormatT | NotGiven,
+    response: Message,
+) -> ParsedMessage[ResponseFormatT]:
+    content_list: list[ParsedContentBlock[ResponseFormatT]] = []
+    for content in response.content:
+        if content.type == "text":
+            content_list.append(
+                construct_type_unchecked(
+                    type_=ParsedTextBlock[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_=ParsedMessage[ResponseFormatT],
+        value={
+            **response.to_dict(),
+            "content": content_list,
+        },
+    )

anthropic/lib/streaming/__init__.py

@@ -6,6 +6,9 @@ from ._types import (
     MessageStopEvent as MessageStopEvent,
     MessageStreamEvent as MessageStreamEvent,
     ContentBlockStopEvent as ContentBlockStopEvent,
+    ParsedMessageStopEvent as ParsedMessageStopEvent,
+    ParsedMessageStreamEvent as ParsedMessageStreamEvent,
+    ParsedContentBlockStopEvent as ParsedContentBlockStopEvent,
 )
 from ._messages import (
     MessageStream as MessageStream,

anthropic/lib/streaming/_messages.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 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
@@ -16,17 +16,21 @@ from ._types import (
     ThinkingEvent,
     InputJsonEvent,
     SignatureEvent,
-    MessageStopEvent,
-    MessageStreamEvent,
-    ContentBlockStopEvent,
+    ParsedMessageStopEvent,
+    ParsedMessageStreamEvent,
+    ParsedContentBlockStopEvent,
 )
-from ...types import Message, ContentBlock, RawMessageStreamEvent
+from ...types import RawMessageStreamEvent
+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 ..._streaming import Stream, AsyncStream
+from ..._utils._utils import is_given
+from .._parse._response import ResponseFormatT, parse_text
+from ...types.parsed_message import ParsedMessage, ParsedContentBlock
 
 
-class MessageStream:
+class MessageStream(Generic[ResponseFormatT]):
     text_stream: Iterator[str]
     """Iterator over just the text deltas in the stream.
 
@@ -37,11 +41,16 @@ class MessageStream:
     ```
     """
 
-    def __init__(self, raw_stream: Stream[RawMessageStreamEvent]) -> None:
+    def __init__(
+        self,
+        raw_stream: Stream[RawMessageStreamEvent],
+        output_format: ResponseFormatT | NotGiven,
+    ) -> None:
         self._raw_stream = raw_stream
         self.text_stream = self.__stream_text__()
         self._iterator = self.__stream__()
-        self.__final_message_snapshot: Message | None = None
+        self.__final_message_snapshot: ParsedMessage[ResponseFormatT] | None = None
+        self.__output_format = output_format
 
     @property
     def response(self) -> httpx.Response:
@@ -51,10 +60,10 @@ class MessageStream:
     def request_id(self) -> str | None:
         return self.response.headers.get("request-id")  # type: ignore[no-any-return]
 
-    def __next__(self) -> MessageStreamEvent:
+    def __next__(self) -> ParsedMessageStreamEvent[ResponseFormatT]:
         return self._iterator.__next__()
 
-    def __iter__(self) -> Iterator[MessageStreamEvent]:
+    def __iter__(self) -> Iterator[ParsedMessageStreamEvent[ResponseFormatT]]:
         for item in self._iterator:
             yield item
 
@@ -77,7 +86,7 @@ class MessageStream:
         """
         self._raw_stream.close()
 
-    def get_final_message(self) -> Message:
+    def get_final_message(self) -> ParsedMessage[ResponseFormatT]:
         """Waits until the stream has been read to completion and returns
         the accumulated `Message` object.
         """
@@ -112,15 +121,16 @@ class MessageStream:
 
     # properties
     @property
-    def current_message_snapshot(self) -> Message:
+    def current_message_snapshot(self) -> ParsedMessage[ResponseFormatT]:
         assert self.__final_message_snapshot is not None
         return self.__final_message_snapshot
 
-    def __stream__(self) -> Iterator[MessageStreamEvent]:
+    def __stream__(self) -> Iterator[ParsedMessageStreamEvent[ResponseFormatT]]:
         for sse_event in self._raw_stream:
             self.__final_message_snapshot = accumulate_event(
                 event=sse_event,
                 current_snapshot=self.__final_message_snapshot,
+                output_format=self.__output_format,
             )
 
             events_to_fire = build_events(event=sse_event, message_snapshot=self.current_message_snapshot)
@@ -133,7 +143,7 @@ class MessageStream:
                 yield chunk.delta.text
 
 
-class MessageStreamManager:
+class MessageStreamManager(Generic[ResponseFormatT]):
     """Wrapper over MessageStream that is returned by `.stream()`.
 
     ```py
@@ -146,13 +156,16 @@ class MessageStreamManager:
     def __init__(
         self,
         api_request: Callable[[], Stream[RawMessageStreamEvent]],
+        *,
+        output_format: ResponseFormatT | NotGiven,
     ) -> None:
-        self.__stream: MessageStream | None = None
+        self.__stream: MessageStream[ResponseFormatT] | None = None
         self.__api_request = api_request
+        self.__output_format = output_format
 
-    def __enter__(self) -> MessageStream:
+    def __enter__(self) -> MessageStream[ResponseFormatT]:
         raw_stream = self.__api_request()
-        self.__stream = MessageStream(raw_stream)
+        self.__stream = MessageStream(raw_stream, output_format=self.__output_format)
         return self.__stream
 
     def __exit__(
@@ -165,7 +178,7 @@ class MessageStreamManager:
             self.__stream.close()
 
 
-class AsyncMessageStream:
+class AsyncMessageStream(Generic[ResponseFormatT]):
     text_stream: AsyncIterator[str]
     """Async iterator over just the text deltas in the stream.
 
@@ -176,11 +189,16 @@ class AsyncMessageStream:
     ```
     """
 
-    def __init__(self, raw_stream: AsyncStream[RawMessageStreamEvent]) -> None:
+    def __init__(
+        self,
+        raw_stream: AsyncStream[RawMessageStreamEvent],
+        output_format: ResponseFormatT | NotGiven,
+    ) -> None:
         self._raw_stream = raw_stream
         self.text_stream = self.__stream_text__()
         self._iterator = self.__stream__()
-        self.__final_message_snapshot: Message | None = None
+        self.__final_message_snapshot: ParsedMessage[ResponseFormatT] | None = None
+        self.__output_format = output_format
 
     @property
     def response(self) -> httpx.Response:
@@ -190,10 +208,10 @@ class AsyncMessageStream:
     def request_id(self) -> str | None:
         return self.response.headers.get("request-id")  # type: ignore[no-any-return]
 
-    async def __anext__(self) -> MessageStreamEvent:
+    async def __anext__(self) -> ParsedMessageStreamEvent[ResponseFormatT]:
         return await self._iterator.__anext__()
 
-    async def __aiter__(self) -> AsyncIterator[MessageStreamEvent]:
+    async def __aiter__(self) -> AsyncIterator[ParsedMessageStreamEvent[ResponseFormatT]]:
         async for item in self._iterator:
             yield item
 
@@ -216,7 +234,7 @@ class AsyncMessageStream:
         """
         await self._raw_stream.close()
 
-    async def get_final_message(self) -> Message:
+    async def get_final_message(self) -> ParsedMessage[ResponseFormatT]:
         """Waits until the stream has been read to completion and returns
         the accumulated `Message` object.
         """
@@ -251,15 +269,16 @@ class AsyncMessageStream:
 
     # properties
     @property
-    def current_message_snapshot(self) -> Message:
+    def current_message_snapshot(self) -> ParsedMessage[ResponseFormatT]:
         assert self.__final_message_snapshot is not None
         return self.__final_message_snapshot
 
-    async def __stream__(self) -> AsyncIterator[MessageStreamEvent]:
+    async def __stream__(self) -> AsyncIterator[ParsedMessageStreamEvent[ResponseFormatT]]:
         async for sse_event in self._raw_stream:
             self.__final_message_snapshot = accumulate_event(
                 event=sse_event,
                 current_snapshot=self.__final_message_snapshot,
+                output_format=self.__output_format,
             )
 
             events_to_fire = build_events(event=sse_event, message_snapshot=self.current_message_snapshot)
@@ -272,7 +291,7 @@ class AsyncMessageStream:
                 yield chunk.delta.text
 
 
-class AsyncMessageStreamManager:
+class AsyncMessageStreamManager(Generic[ResponseFormatT]):
     """Wrapper over AsyncMessageStream that is returned by `.stream()`
     so that an async context manager can be used without `await`ing the
     original client call.
@@ -287,13 +306,16 @@ class AsyncMessageStreamManager:
     def __init__(
         self,
         api_request: Awaitable[AsyncStream[RawMessageStreamEvent]],
+        *,
+        output_format: ResponseFormatT | NotGiven = NOT_GIVEN,
     ) -> None:
-        self.__stream: AsyncMessageStream | None = None
+        self.__stream: AsyncMessageStream[ResponseFormatT] | None = None
         self.__api_request = api_request
+        self.__output_format = output_format
 
-    async def __aenter__(self) -> AsyncMessageStream:
+    async def __aenter__(self) -> AsyncMessageStream[ResponseFormatT]:
         raw_stream = await self.__api_request
-        self.__stream = AsyncMessageStream(raw_stream)
+        self.__stream = AsyncMessageStream(raw_stream, output_format=self.__output_format)
         return self.__stream
 
     async def __aexit__(
@@ -309,16 +331,18 @@ class AsyncMessageStreamManager:
 def build_events(
     *,
     event: RawMessageStreamEvent,
-    message_snapshot: Message,
-) -> list[MessageStreamEvent]:
-    events_to_fire: list[MessageStreamEvent] = []
+    message_snapshot: ParsedMessage[ResponseFormatT],
+) -> list[ParsedMessageStreamEvent[ResponseFormatT]]:
+    events_to_fire: list[ParsedMessageStreamEvent[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(MessageStopEvent, type="message_stop", message=message_snapshot))
+        events_to_fire.append(
+            build(ParsedMessageStopEvent[ResponseFormatT], type="message_stop", message=message_snapshot)
+        )
     elif event.type == "content_block_start":
         events_to_fire.append(event)
     elif event.type == "content_block_delta":
@@ -382,9 +406,14 @@ def build_events(
     elif event.type == "content_block_stop":
         content_block = message_snapshot.content[event.index]
 
-        events_to_fire.append(
-            build(ContentBlockStopEvent, type="content_block_stop", index=event.index, content_block=content_block),
+        event_to_fire = build(
+            ParsedContentBlockStopEvent,
+            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]
@@ -404,8 +433,9 @@ TRACKS_TOOL_INPUT = (
 def accumulate_event(
     *,
     event: RawMessageStreamEvent,
-    current_snapshot: Message | None,
-) -> Message:
+    current_snapshot: ParsedMessage[ResponseFormatT] | None,
+    output_format: ResponseFormatT | NotGiven = NOT_GIVEN,
+) -> ParsedMessage[ResponseFormatT]:
     if not isinstance(cast(Any, event), BaseModel):
         event = cast(  # pyright: ignore[reportUnnecessaryCast]
             RawMessageStreamEvent,
@@ -419,7 +449,7 @@ def accumulate_event(
 
     if current_snapshot is None:
         if event.type == "message_start":
-            return Message.construct(**cast(Any, event.message.to_dict()))
+            return cast(ParsedMessage[ResponseFormatT], ParsedMessage.construct(**cast(Any, event.message.to_dict())))
 
         raise RuntimeError(f'Unexpected event order, got {event.type} before "message_start"')
 
@@ -427,8 +457,8 @@ def accumulate_event(
         # TODO: check index
         current_snapshot.content.append(
             cast(
-                ContentBlock,
-                construct_type(type_=ContentBlock, value=event.content_block.model_dump()),
+                Any,  # Pydantic does not support generic unions at runtime
+                construct_type(type_=ParsedContentBlock, value=event.content_block.model_dump()),
             ),
         )
     elif event.type == "content_block_delta":
@@ -466,6 +496,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.stop_reason = event.delta.stop_reason
         current_snapshot.stop_sequence = event.delta.stop_sequence

anthropic/lib/streaming/_types.py

@@ -1,6 +1,8 @@
-from typing import Union
+from typing import TYPE_CHECKING, Any, Dict, Union, Generic, cast
 from typing_extensions import List, Literal, Annotated
 
+import jiter
+
 from ...types import (
     Message,
     ContentBlock,
@@ -11,8 +13,10 @@ from ...types import (
     ContentBlockStartEvent as RawContentBlockStartEvent,
     RawContentBlockStopEvent,
 )
-from ..._models import BaseModel
+from ..._models import BaseModel, GenericModel
+from .._parse._response import ResponseFormatT
 from ..._utils._transform import PropertyInfo
+from ...types.parsed_message import ParsedMessage, ParsedContentBlock
 from ...types.citations_delta import Citation
 
 
@@ -25,6 +29,9 @@ class TextEvent(BaseModel):
     snapshot: str
     """The entire accumulated text"""
 
+    def parsed_snapshot(self) -> Dict[str, Any]:
+        return cast(Dict[str, Any], jiter.from_json(self.snapshot.encode("utf-8"), partial_mode="trailing-strings"))
+
 
 class CitationEvent(BaseModel):
     type: Literal["citation"]
@@ -98,3 +105,36 @@ MessageStreamEvent = Annotated[
     ],
     PropertyInfo(discriminator="type"),
 ]
+
+
+class ParsedMessageStopEvent(RawMessageStopEvent, GenericModel, Generic[ResponseFormatT]):
+    type: Literal["message_stop"]
+
+    message: ParsedMessage[ResponseFormatT]
+
+
+class ParsedContentBlockStopEvent(RawContentBlockStopEvent, GenericModel, Generic[ResponseFormatT]):
+    type: Literal["content_block_stop"]
+
+    if TYPE_CHECKING:
+        content_block: ParsedContentBlock[ResponseFormatT]
+    else:
+        content_block: ParsedContentBlock
+
+
+ParsedMessageStreamEvent = Annotated[
+    Union[
+        TextEvent,
+        CitationEvent,
+        ThinkingEvent,
+        SignatureEvent,
+        InputJsonEvent,
+        RawMessageStartEvent,
+        RawMessageDeltaEvent,
+        ParsedMessageStopEvent[ResponseFormatT],
+        RawContentBlockStartEvent,
+        RawContentBlockDeltaEvent,
+        ParsedContentBlockStopEvent[ResponseFormatT],
+    ],
+    PropertyInfo(discriminator="type"),
+]