anthropic 0.72.1__tar.gz → 0.74.0__tar.gz

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

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

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

@@ -1,5 +1,37 @@
 # Changelog
 
+## 0.74.0 (2025-11-18)
+
+Full Changelog: [v0.73.0...v0.74.0](https://github.com/anthropics/anthropic-sdk-python/compare/v0.73.0...v0.74.0)
+
+### Features
+
+* add Foundry SDK ([3ae9e45](https://github.com/anthropics/anthropic-sdk-python/commit/3ae9e45451d3ff85b25ba5f5f9f8786ea35e3cc9))
+
+
+### Bug Fixes
+
+* **examples/memory:** properly add assistant_content to messages ([#1049](https://github.com/anthropics/anthropic-sdk-python/issues/1049)) ([9c7141b](https://github.com/anthropics/anthropic-sdk-python/commit/9c7141b887bbde251b6b740405a91d1726308c32))
+* use posix paths in file collection for cross-platform compatibility ([d9c6f40](https://github.com/anthropics/anthropic-sdk-python/commit/d9c6f4006a43fe094acbf652a8dbd4234853ed70)), closes [#1051](https://github.com/anthropics/anthropic-sdk-python/issues/1051)
+
+
+### Chores
+
+* **internal:** remove unnecessary wrapper around external snapshots ([19eceac](https://github.com/anthropics/anthropic-sdk-python/commit/19eceac2406e4c71db14f9e870aaa901b4249219))
+
+
+### Documentation
+
+* explain snapshot update process ([#1040](https://github.com/anthropics/anthropic-sdk-python/issues/1040)) ([b61fd87](https://github.com/anthropics/anthropic-sdk-python/commit/b61fd87986a90105c20d4f35e34a9f69ec73645f))
+
+## 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.74.0}/CONTRIBUTING.md

@@ -96,6 +96,28 @@ $ npx prism mock path/to/your/openapi.yml
 $ ./scripts/test
 ```
 
+### Snapshots
+
+Some tests use [inline-snapshot](https://15r10nk.github.io/inline-snapshot/latest/). To update them after making changes, rerun the tests with the `--inline-snapshot=fix` and `-n0` options:
+
+```bash
+./scripts/test --inline-snapshot=fix -n0
+```
+
+> [!NOTE]
+> `inline-snapshot` is incompatible with [pytest-xdist](https://github.com/pytest-dev/pytest-xdist), so you need to disable parallel execution `(-n0)` when using the `--inline-snapshot` option.
+
+In addition, some tests capture snapshots of the HTTP requests they make.
+To refresh these snapshots, run the tests with the `ANTHROPIC_LIVE=1` environment variable enabled.
+
+```bash
+ANTHROPIC_LIVE=1 ./scripts/test --inline-snapshot=fix
+```
+
+> [!NOTE]
+> Sometimes it makes sense to update only the inline snapshots `(--inline-snapshot=fix)` without refreshing the HTTP snapshots `(ANTHROPIC_LIVE=1)`.
+> This is useful when the endpoint hasn’t changed, but your code handles the response differently and the assertions need updating.
+
 ## Linting and formatting
 
 This repository uses [ruff](https://github.com/astral-sh/ruff) and

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: anthropic
-Version: 0.72.1
+Version: 0.74.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.74.0}/api.md

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

anthropic-0.74.0/examples/azure.py

@@ -0,0 +1,26 @@
+# /// script
+# requires-python = ">=3.9"
+# dependencies = [
+#     "anthropic",
+# ]
+#
+# [tool.uv.sources]
+# anthropic = { path = "../", editable = true }
+# ///
+
+from anthropic import AnthropicFoundry
+
+cl = AnthropicFoundry(
+    resource="your-resource-name",
+    api_key="your-foundry-anthropic-api-key",
+)
+
+response = cl.messages.create(
+    model="claude-haiku-4-5",
+    messages=[
+        {"role": "user", "content": "Hello!"},
+    ],
+    max_tokens=1024,
+)
+
+print(response)

{anthropic-0.72.1 → anthropic-0.74.0}/examples/memory/basic.py

@@ -335,7 +335,6 @@ def conversation_loop():
             raise
 
         # Process all messages from the runner
-        assistant_content: list[BetaContentBlockParam] = []
         for message in runner:
             spinner.stop()
 
@@ -351,6 +350,7 @@ def conversation_loop():
                     print(f"\n🧹 [Context Management: {edit.type} applied]")
 
             # Process content blocks
+            assistant_content: list[BetaContentBlockParam] = []
             for content in message.content:
                 if content.type == "text":
                     print(content.text, end="", flush=True)
@@ -371,6 +371,10 @@ def conversation_loop():
                         }
                     )
 
+            # Store assistant message
+            if assistant_content:
+                messages.append({"role": "assistant", "content": assistant_content})
+
             # Generate tool response automatically
             tool_response = runner.generate_tool_call_response()
             if tool_response and tool_response["content"]:
@@ -381,10 +385,6 @@ def conversation_loop():
                     if isinstance(result, dict) and result.get("type") == "tool_result":
                         print(f"[Tool result processed]")
 
-        # Store assistant message
-        if assistant_content:
-            messages.append({"role": "assistant", "content": assistant_content})
-
         print()
 
 

anthropic-0.74.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.74.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.74.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "anthropic"
-version = "0.72.1"
+version = "0.74.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.74.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:
@@ -99,6 +101,7 @@ if not _t.TYPE_CHECKING:
 from .lib.tools import beta_tool, beta_async_tool
 from .lib.vertex import *
 from .lib.bedrock import *
+from .lib.foundry import AnthropicFoundry as AnthropicFoundry, AsyncAnthropicFoundry as AsyncAnthropicFoundry
 from .lib.streaming import *
 
 _setup_logging()

{anthropic-0.72.1 → anthropic-0.74.0}/src/anthropic/_client.py

@@ -183,6 +183,10 @@ class Anthropic(SyncAPIClient):
 
     @override
     def _validate_headers(self, headers: Headers, custom_headers: Headers) -> None:
+        if headers.get("Authorization") or headers.get("X-Api-Key"):
+            # valid
+            return
+
         if self.api_key and headers.get("X-Api-Key"):
             return
         if isinstance(custom_headers.get("X-Api-Key"), Omit):
@@ -423,6 +427,10 @@ class AsyncAnthropic(AsyncAPIClient):
 
     @override
     def _validate_headers(self, headers: Headers, custom_headers: Headers) -> None:
+        if headers.get("Authorization") or headers.get("X-Api-Key"):
+            # valid
+            return
+
         if self.api_key and headers.get("X-Api-Key"):
             return
         if isinstance(custom_headers.get("X-Api-Key"), Omit):

{anthropic-0.72.1 → anthropic-0.74.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.74.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.74.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.74.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.74.0"  # x-release-please-version

{anthropic-0.72.1 → anthropic-0.74.0}/src/anthropic/lib/_files.py

@@ -22,7 +22,7 @@ def _collect_files(directory: Path, relative_to: Path, files: list[FileTypes]) -
             _collect_files(path, relative_to, files)
             continue
 
-        files.append((str(path.relative_to(relative_to)), path.read_bytes()))
+        files.append((path.relative_to(relative_to).as_posix(), path.read_bytes()))
 
 
 async def async_files_from_dir(directory: str | os.PathLike[str]) -> list[FileTypes]:
@@ -39,4 +39,4 @@ async def _async_collect_files(directory: anyio.Path, relative_to: anyio.Path, f
             await _async_collect_files(path, relative_to, files)
             continue
 
-        files.append((str(path.relative_to(relative_to)), await path.read_bytes()))
+        files.append((path.relative_to(relative_to).as_posix(), await path.read_bytes()))

anthropic-0.74.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.74.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