anthropic 0.72.1__tar.gz → 0.73.0__tar.gz

anthropic-0.73.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.73.0"
+}

{anthropic-0.72.1 → anthropic-0.73.0}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.73.0 (2025-11-14)
+
+Full Changelog: [v0.72.1...v0.73.0](https://github.com/anthropics/anthropic-sdk-python/compare/v0.72.1...v0.73.0)
+
+### Features
+
+* **api:** add support for structured outputs beta ([688da81](https://github.com/anthropics/anthropic-sdk-python/commit/688da8126df8a304c5f01f0dc63cda437a62c217))
+
 ## 0.72.1 (2025-11-11)
 
 Full Changelog: [v0.72.0...v0.72.1](https://github.com/anthropics/anthropic-sdk-python/compare/v0.72.0...v0.72.1)

{anthropic-0.72.1 → anthropic-0.73.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: anthropic
-Version: 0.72.1
+Version: 0.73.0
 Summary: The official Python library for the anthropic API
 Project-URL: Homepage, https://github.com/anthropics/anthropic-sdk-python
 Project-URL: Repository, https://github.com/anthropics/anthropic-sdk-python

{anthropic-0.72.1 → anthropic-0.73.0}/api.md

@@ -263,6 +263,7 @@ from anthropic.types.beta import (
     BetaInputJSONDelta,
     BetaInputTokensClearAtLeast,
     BetaInputTokensTrigger,
+    BetaJSONOutputFormat,
     BetaMCPToolResultBlock,
     BetaMCPToolUseBlock,
     BetaMCPToolUseBlockParam,

anthropic-0.73.0/examples/structured_outputs.py

@@ -0,0 +1,37 @@
+# /// script
+# requires-python = ">=3.9"
+# dependencies = [
+#     "anthropic",
+# ]
+#
+# [tool.uv.sources]
+# anthropic = { path = "../", editable = true }
+# ///
+
+
+import pydantic
+
+import anthropic
+
+
+class Order(pydantic.BaseModel):
+    product_name: str
+    price: float
+    quantity: int
+
+
+client = anthropic.Anthropic()
+
+prompt = """
+Extract the product name, price, and quantity from this customer message:
+"Hi, I’d like to order 2 packs of Green Tea for 5.50 dollars each."
+"""
+
+parsed_message = client.beta.messages.parse(
+    model="claude-sonnet-4-5-20250929-structured-outputs",
+    messages=[{"role": "user", "content": prompt}],
+    max_tokens=1024,
+    output_format=Order,
+)
+
+print(parsed_message.parsed_output)  # Order(product_name='Green Tea', price=5.5, quantity=2)

anthropic-0.73.0/examples/structured_outputs_streaming.py

@@ -0,0 +1,38 @@
+# /// script
+# requires-python = ">=3.9"
+# dependencies = [
+#     "anthropic",
+# ]
+#
+# [tool.uv.sources]
+# anthropic = { path = "../", editable = true }
+# ///
+
+import pydantic
+
+import anthropic
+
+
+class Order(pydantic.BaseModel):
+    product_name: str
+    price: float
+    quantity: int
+
+
+client = anthropic.Anthropic()
+
+prompt = """
+Extract the product name, price, and quantity from this customer message:
+"Hi, I’d like to order 2 packs of Green Tea for 5.50 dollars each."
+"""
+
+with client.beta.messages.stream(
+    model="claude-sonnet-4-5-20250929-structured-outputs",
+    messages=[{"role": "user", "content": prompt}],
+    betas=["structured-outputs-2025-09-17"],
+    max_tokens=1024,
+    output_format=Order,
+) as stream:
+    for event in stream:
+        if event.type == "text":
+            print(event.parsed_snapshot())

{anthropic-0.72.1 → anthropic-0.73.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "anthropic"
-version = "0.72.1"
+version = "0.73.0"
 description = "The official Python library for the anthropic API"
 dynamic = ["readme"]
 license = "MIT"
@@ -160,7 +160,7 @@ show_error_codes = true
 #
 # We also exclude our `tests` as mypy doesn't always infer
 # types correctly and Pyright will still catch any type errors.
-exclude = ['src/anthropic/_files.py', '_dev/.*.py', 'tests/.*', 'examples/mcp_server_weather.py', 'examples/tools_with_mcp.py', 'examples/memory/basic.py']
+exclude = ['src/anthropic/_files.py', '_dev/.*.py', 'tests/.*', 'examples/mcp_server_weather.py', 'examples/tools_with_mcp.py', 'examples/memory/basic.py', 'src/anthropic/lib/_parse/_transform.py']
 
 strict_equality = true
 implicit_reexport = true

{anthropic-0.72.1 → anthropic-0.73.0}/src/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-0.72.1 → anthropic-0.73.0}/src/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-0.72.1 → anthropic-0.73.0}/src/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-0.72.1 → anthropic-0.73.0}/src/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-0.72.1 → anthropic-0.73.0}/src/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-0.73.0/src/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-0.73.0/src/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-0.72.1 → anthropic-0.73.0}/src/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,