anthropic 0.75.0__py3-none-any.whl → 0.77.0__py3-none-any.whl

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"),
+]

anthropic/lib/tools/_beta_compaction_control.py

@@ -31,9 +31,9 @@ DEFAULT_THRESHOLD = 100_000
 class CompactionControl(TypedDict, total=False):
     context_token_threshold: int
     """The context token threshold at which to trigger compaction.
-    
+
     When the cumulative token count (input + output) across all messages exceeds this threshold,
-    the message history will be automatically summarized and compressed. Defaults to 150,000 tokens.
+    the message history will be automatically summarized and compressed. Defaults to 100,000 tokens.
     """
 
     model: str

anthropic/lib/tools/_beta_runner.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+import warnings
 from abc import ABC, abstractmethod
 from typing import (
     TYPE_CHECKING,
@@ -298,6 +299,14 @@ class BaseSyncToolRunner(BaseToolRunner[BetaRunnableTool, ResponseFormatT], Gene
         for tool_use in tool_use_blocks:
             tool = self._tools_by_name.get(tool_use.name)
             if tool is None:
+                warnings.warn(
+                    f"Tool '{tool_use.name}' not found in tool runner. "
+                    f"Available tools: {list(self._tools_by_name.keys())}. "
+                    f"If using a raw tool definition, handle the tool call manually and use `append_messages()` to add the result. "
+                    f"Otherwise, pass the tool using `beta_tool(func)` or a `@beta_tool` decorated function.",
+                    UserWarning,
+                    stacklevel=3,
+                )
                 results.append(
                     {
                         "type": "tool_result",
@@ -554,6 +563,14 @@ class BaseAsyncToolRunner(
         for tool_use in tool_use_blocks:
             tool = self._tools_by_name.get(tool_use.name)
             if tool is None:
+                warnings.warn(
+                    f"Tool '{tool_use.name}' not found in tool runner. "
+                    f"Available tools: {list(self._tools_by_name.keys())}. "
+                    f"If using a raw tool definition, handle the tool call manually and use `append_messages()` to add the result. "
+                    f"Otherwise, pass the tool using `beta_async_tool(func)` or a `@beta_async_tool` decorated function.",
+                    UserWarning,
+                    stacklevel=3,
+                )
                 results.append(
                     {
                         "type": "tool_result",