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

anthropic/__init__.py

@@ -101,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/_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/_version.py

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

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/lib/foundry.md

@@ -0,0 +1,127 @@
+# Anthropic Foundry
+
+To use this library with Foundry, use the `AnthropicFoundry` class instead of the `Anthropic` class.
+
+
+## Installation
+
+```bash
+pip install anthropic
+```
+
+## Usage
+
+### Basic Usage with API Key
+
+```python
+from anthropic import AnthropicFoundry
+
+client = AnthropicFoundry(
+    api_key="...",  # defaults to ANTHROPIC_FOUNDRY_API_KEY environment variable
+    resource="my-resource",  # your Foundry resource
+)
+
+message = client.messages.create(
+    model="claude-3-5-sonnet-20241022",
+    max_tokens=1024,
+    messages=[{"role": "user", "content": "Hello!"}],
+)
+
+print(message.content[0].text)
+```
+
+### Using Azure AD Token Provider
+
+For enhanced security, you can use Azure AD (Microsoft Entra) authentication instead of an API key:
+
+```python
+from anthropic import AnthropicFoundry
+from azure.identity import DefaultAzureCredential
+from azure.identity import get_bearer_token_provider
+
+credential = DefaultAzureCredential()
+token_provider = get_bearer_token_provider(
+    credential, 
+    "https://ai.azure.com/.default"
+)
+
+client = AnthropicFoundry(
+    azure_ad_token_provider=token_provider,
+    resource="my-resource",
+)
+
+message = client.messages.create(
+    model="claude-3-5-sonnet-20241022",
+    max_tokens=1024,
+    messages=[{"role": "user", "content": "Hello!"}],
+)
+
+print(message.content[0].text)
+```
+
+## Examples
+
+### Streaming Messages
+
+```python
+from anthropic import AnthropicFoundry
+
+client = AnthropicFoundry(
+    api_key="...",
+    resource="my-resource",
+)
+
+with client.messages.stream(
+    model="claude-3-5-sonnet-20241022",
+    max_tokens=1024,
+    messages=[{"role": "user", "content": "Write a haiku about programming"}],
+) as stream:
+    for text in stream.text_stream:
+        print(text, end="", flush=True)
+```
+
+### Async Usage
+
+```python
+from anthropic import AsyncAnthropicFoundry
+
+async def main():
+    client = AsyncAnthropicFoundry(
+        api_key="...",
+        resource="my-resource",
+    )
+    
+    message = await client.messages.create(
+        model="claude-3-5-sonnet-20241022",
+        max_tokens=1024,
+        messages=[{"role": "user", "content": "Hello!"}],
+    )
+    
+    print(message.content[0].text)
+
+import asyncio
+asyncio.run(main())
+```
+
+### Async Streaming
+
+```python
+from anthropic import AsyncAnthropicFoundry
+
+async def main():
+    client = AsyncAnthropicFoundry(
+        api_key="...",
+        resource="my-resource",
+    )
+    
+    async with client.messages.stream(
+        model="claude-3-5-sonnet-20241022",
+        max_tokens=1024,
+        messages=[{"role": "user", "content": "Write a haiku about programming"}],
+    ) as stream:
+        async for text in stream.text_stream:
+            print(text, end="", flush=True)
+
+import asyncio
+asyncio.run(main())
+```

anthropic/lib/foundry.py

@@ -0,0 +1,443 @@
+from __future__ import annotations
+
+import os
+import inspect
+from typing import Any, Union, Mapping, TypeVar, Callable, Awaitable, cast, overload
+from functools import cached_property
+from typing_extensions import Self, override
+
+import httpx
+
+from .._types import NOT_GIVEN, Omit, Timeout, NotGiven
+from .._utils import is_given
+from .._client import Anthropic, AsyncAnthropic
+from .._compat import model_copy
+from .._models import FinalRequestOptions
+from .._streaming import Stream, AsyncStream
+from .._exceptions import AnthropicError
+from .._base_client import DEFAULT_MAX_RETRIES, BaseClient
+from ..resources.beta import Beta, AsyncBeta
+from ..resources.messages import Messages, AsyncMessages
+from ..resources.beta.messages import Messages as BetaMessages, AsyncMessages as AsyncBetaMessages
+
+AzureADTokenProvider = Callable[[], str]
+AsyncAzureADTokenProvider = Callable[[], "str | Awaitable[str]"]
+_HttpxClientT = TypeVar("_HttpxClientT", bound=Union[httpx.Client, httpx.AsyncClient])
+_DefaultStreamT = TypeVar("_DefaultStreamT", bound=Union[Stream[Any], AsyncStream[Any]])
+
+
+class MutuallyExclusiveAuthError(AnthropicError):
+    def __init__(self) -> None:
+        super().__init__(
+            "The `api_key` and `azure_ad_token_provider` arguments are mutually exclusive; Only one can be passed at a time"
+        )
+
+
+class BaseFoundryClient(BaseClient[_HttpxClientT, _DefaultStreamT]): ...
+
+
+class MessagesFoundry(Messages):
+    @cached_property
+    @override
+    def batches(self) -> None:  # type: ignore[override]
+        """Batches endpoint is not supported for Anthropic Foundry client."""
+        return None
+
+
+class BetaFoundryMessages(BetaMessages):
+    @cached_property
+    @override
+    def batches(self) -> None:  # type: ignore[override]
+        """Batches endpoint is not supported for Anthropic Foundry client."""
+        return None
+
+
+class BetaFoundry(Beta):
+    @cached_property
+    @override
+    def messages(self) -> BetaMessages:  # type: ignore[override]
+        """Return beta messages resource instance with excluded unsupported endpoints."""
+        return BetaFoundryMessages(self._client)
+
+
+class AsyncMessagesFoundry(AsyncMessages):
+    @cached_property
+    @override
+    def batches(self) -> None:  # type: ignore[override]
+        """Batches endpoint is not supported for Anthropic Foundry client."""
+        return None
+
+
+class AsyncBetaFoundryMessages(AsyncBetaMessages):
+    @cached_property
+    @override
+    def batches(self) -> None:  # type: ignore[override]
+        """Batches endpoint is not supported for Anthropic Foundry client."""
+        return None
+
+
+class AsyncBetaFoundry(AsyncBeta):
+    @cached_property
+    @override
+    def messages(self) -> AsyncBetaMessages:  # type: ignore[override]
+        """Return beta messages resource instance with excluded unsupported endpoints."""
+        return AsyncBetaFoundryMessages(self._client)
+
+
+# ==============================================================================
+
+
+class AnthropicFoundry(BaseFoundryClient[httpx.Client, Stream[Any]], Anthropic):
+    @overload
+    def __init__(
+        self,
+        *,
+        resource: str | None = None,
+        api_key: str | None = None,
+        azure_ad_token_provider: AzureADTokenProvider | None = None,
+        timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        default_headers: Mapping[str, str] | None = None,
+        default_query: Mapping[str, object] | None = None,
+        http_client: httpx.Client | None = None,
+        _strict_response_validation: bool = False,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        api_key: str | None = None,
+        azure_ad_token_provider: AzureADTokenProvider | None = None,
+        timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        default_headers: Mapping[str, str] | None = None,
+        default_query: Mapping[str, object] | None = None,
+        http_client: httpx.Client | None = None,
+        _strict_response_validation: bool = False,
+    ) -> None: ...
+
+    def __init__(
+        self,
+        *,
+        resource: str | None = None,
+        api_key: str | None = None,
+        azure_ad_token_provider: AzureADTokenProvider | None = None,
+        base_url: str | None = None,
+        timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        default_headers: Mapping[str, str] | None = None,
+        default_query: Mapping[str, object] | None = None,
+        http_client: httpx.Client | None = None,
+        _strict_response_validation: bool = False,
+    ) -> None:
+        """Construct a new synchronous Anthropic Foundry client instance.
+
+        This automatically infers the following arguments from their corresponding environment variables if they are not provided:
+        - `api_key` from `ANTHROPIC_FOUNDRY_API_KEY`
+        - `resource` from `ANTHROPIC_FOUNDRY_RESOURCE`
+        - `base_url` from `ANTHROPIC_FOUNDRY_BASE_URL`
+
+        Args:
+            resource: Your Foundry resource name, e.g. `example-resource` for `https://example-resource.services.ai.azure.com/anthropic/`
+            azure_ad_token_provider: A function that returns an Azure Active Directory token, will be invoked on every request.
+        """
+        api_key = api_key if api_key is not None else os.environ.get("ANTHROPIC_FOUNDRY_API_KEY")
+        resource = resource if resource is not None else os.environ.get("ANTHROPIC_FOUNDRY_RESOURCE")
+        base_url = base_url if base_url is not None else os.environ.get("ANTHROPIC_FOUNDRY_BASE_URL")
+
+        if api_key is None and azure_ad_token_provider is None:
+            raise AnthropicError(
+                "Missing credentials. Please pass one of `api_key`, `azure_ad_token_provider`, or the `ANTHROPIC_FOUNDRY_API_KEY` environment variable."
+            )
+
+        if base_url is None:
+            if resource is None:
+                raise ValueError(
+                    "Must provide one of the `base_url` or `resource` arguments, or the `ANTHROPIC_FOUNDRY_RESOURCE` environment variable"
+                )
+            base_url = f"https://{resource}.services.ai.azure.com/anthropic/"
+        elif resource is not None:
+            raise ValueError("base_url and resource are mutually exclusive")
+
+        super().__init__(
+            api_key=api_key,
+            base_url=base_url,
+            timeout=timeout,
+            max_retries=max_retries,
+            default_headers=default_headers,
+            default_query=default_query,
+            http_client=http_client,
+            _strict_response_validation=_strict_response_validation,
+        )
+        self._azure_ad_token_provider = azure_ad_token_provider
+
+    @cached_property
+    @override
+    def models(self) -> None:  # type: ignore[override]
+        """Models endpoint is not supported for Anthropic Foundry client."""
+        return None
+
+    @cached_property
+    @override
+    def messages(self) -> MessagesFoundry:  # type: ignore[override]
+        """Return messages resource instance with excluded unsupported endpoints."""
+        return MessagesFoundry(client=self)
+
+    @cached_property
+    @override
+    def beta(self) -> Beta:  # type: ignore[override]
+        """Return beta resource instance with excluded unsupported endpoints."""
+        return BetaFoundry(self)
+
+    @override
+    def copy(
+        self,
+        *,
+        api_key: str | None = None,
+        azure_ad_token_provider: AzureADTokenProvider | None = None,
+        auth_token: str | None = None,
+        base_url: str | httpx.URL | None = None,
+        timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
+        http_client: httpx.Client | None = None,
+        max_retries: int | NotGiven = NOT_GIVEN,
+        default_headers: Mapping[str, str] | None = None,
+        set_default_headers: Mapping[str, str] | None = None,
+        default_query: Mapping[str, object] | None = None,
+        set_default_query: Mapping[str, object] | None = None,
+        _extra_kwargs: Mapping[str, Any] = {},
+    ) -> Self:
+        """
+        Create a new client instance re-using the same options given to the current client with optional overriding.
+        """
+        return super().copy(
+            api_key=api_key,
+            auth_token=auth_token,
+            base_url=base_url,
+            timeout=timeout,
+            http_client=http_client,
+            max_retries=max_retries,
+            default_headers=default_headers,
+            set_default_headers=set_default_headers,
+            default_query=default_query,
+            set_default_query=set_default_query,
+            _extra_kwargs={
+                "azure_ad_token_provider": azure_ad_token_provider or self._azure_ad_token_provider,
+                **_extra_kwargs,
+            },
+        )
+
+    with_options = copy
+
+    def _get_azure_ad_token(self) -> str | None:
+        provider = self._azure_ad_token_provider
+        if provider is not None:
+            token = provider()
+            if not token or not isinstance(token, str):  # pyright: ignore[reportUnnecessaryIsInstance]
+                raise ValueError(
+                    f"Expected `azure_ad_token_provider` argument to return a string but it returned {token}",
+                )
+            return token
+
+        return None
+
+    @override
+    def _prepare_options(self, options: FinalRequestOptions) -> FinalRequestOptions:
+        headers: dict[str, str | Omit] = {**options.headers} if is_given(options.headers) else {}
+
+        options = model_copy(options)
+        options.headers = headers
+
+        azure_ad_token = self._get_azure_ad_token()
+        if azure_ad_token is not None:
+            if headers.get("Authorization") is None:
+                headers["Authorization"] = f"Bearer {azure_ad_token}"
+        elif self.api_key is not None:
+            if headers.get("api-key") is None:
+                assert self.api_key is not None
+                headers["api-key"] = self.api_key
+        else:
+            # should never be hit
+            raise ValueError("Unable to handle auth")
+
+        return options
+
+
+class AsyncAnthropicFoundry(BaseFoundryClient[httpx.AsyncClient, AsyncStream[Any]], AsyncAnthropic):
+    @overload
+    def __init__(
+        self,
+        *,
+        resource: str | None = None,
+        api_key: str | None = None,
+        azure_ad_token_provider: AsyncAzureADTokenProvider | None = None,
+        timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        default_headers: Mapping[str, str] | None = None,
+        default_query: Mapping[str, object] | None = None,
+        http_client: httpx.AsyncClient | None = None,
+        _strict_response_validation: bool = False,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        api_key: str | None = None,
+        azure_ad_token_provider: AsyncAzureADTokenProvider | None = None,
+        timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        default_headers: Mapping[str, str] | None = None,
+        default_query: Mapping[str, object] | None = None,
+        http_client: httpx.AsyncClient | None = None,
+        _strict_response_validation: bool = False,
+    ) -> None: ...
+
+    def __init__(
+        self,
+        *,
+        resource: str | None = None,
+        api_key: str | None = None,
+        azure_ad_token_provider: AsyncAzureADTokenProvider | None = None,
+        base_url: str | None = None,
+        timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        default_headers: Mapping[str, str] | None = None,
+        default_query: Mapping[str, object] | None = None,
+        http_client: httpx.AsyncClient | None = None,
+        _strict_response_validation: bool = False,
+    ) -> None:
+        """Construct a new asynchronous Anthropic Foundry client instance.
+
+        This automatically infers the following arguments from their corresponding environment variables if they are not provided:
+        - `api_key` from `ANTHROPIC_FOUNDRY_API_KEY`
+        - `resource` from `ANTHROPIC_FOUNDRY_RESOURCE`
+        - `base_url` from `ANTHROPIC_FOUNDRY_BASE_URL`
+
+        Args:
+            resource: Your Foundry resource name, e.g. `example-resource` for `https://example-resource.services.ai.azure.com/anthropic/`
+            azure_ad_token_provider: A function that returns an Azure Active Directory token, will be invoked on every request.
+        """
+        api_key = api_key if api_key is not None else os.environ.get("ANTHROPIC_FOUNDRY_API_KEY")
+        resource = resource if resource is not None else os.environ.get("ANTHROPIC_FOUNDRY_RESOURCE")
+        base_url = base_url if base_url is not None else os.environ.get("ANTHROPIC_FOUNDRY_BASE_URL")
+
+        if api_key is None and azure_ad_token_provider is None:
+            raise AnthropicError(
+                "Missing credentials. Please pass one of `api_key`, `azure_ad_token_provider`, or the `ANTHROPIC_FOUNDRY_API_KEY` environment variable."
+            )
+
+        if base_url is None:
+            if resource is None:
+                raise ValueError(
+                    "Must provide one of the `base_url` or `resource` arguments, or the `ANTHROPIC_FOUNDRY_RESOURCE` environment variable"
+                )
+            base_url = f"https://{resource}.services.ai.azure.com/anthropic/"
+        elif resource is not None:
+            raise ValueError("base_url and resource are mutually exclusive")
+
+        super().__init__(
+            api_key=api_key,
+            base_url=base_url,
+            timeout=timeout,
+            max_retries=max_retries,
+            default_headers=default_headers,
+            default_query=default_query,
+            http_client=http_client,
+            _strict_response_validation=_strict_response_validation,
+        )
+        self._azure_ad_token_provider = azure_ad_token_provider
+
+    @cached_property
+    @override
+    def models(self) -> None:  # type: ignore[override]
+        """Models endpoint is not supported for Azure Anthropic client."""
+        return None
+
+    @cached_property
+    @override
+    def messages(self) -> AsyncMessagesFoundry:  # type: ignore[override]
+        """Return messages resource instance with excluded unsupported endpoints."""
+        return AsyncMessagesFoundry(client=self)
+
+    @cached_property
+    @override
+    def beta(self) -> AsyncBetaFoundry:  # type: ignore[override]
+        """Return beta resource instance with excluded unsupported endpoints."""
+        return AsyncBetaFoundry(client=self)
+
+    @override
+    def copy(
+        self,
+        *,
+        api_key: str | None = None,
+        azure_ad_token_provider: AsyncAzureADTokenProvider | None = None,
+        auth_token: str | None = None,
+        base_url: str | httpx.URL | None = None,
+        timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
+        http_client: httpx.AsyncClient | None = None,
+        max_retries: int | NotGiven = NOT_GIVEN,
+        default_headers: Mapping[str, str] | None = None,
+        set_default_headers: Mapping[str, str] | None = None,
+        default_query: Mapping[str, object] | None = None,
+        set_default_query: Mapping[str, object] | None = None,
+        _extra_kwargs: Mapping[str, Any] = {},
+    ) -> Self:
+        """
+        Create a new client instance re-using the same options given to the current client with optional overriding.
+        """
+        return super().copy(
+            api_key=api_key,
+            auth_token=auth_token,
+            base_url=base_url,
+            timeout=timeout,
+            http_client=http_client,
+            max_retries=max_retries,
+            default_headers=default_headers,
+            set_default_headers=set_default_headers,
+            default_query=default_query,
+            set_default_query=set_default_query,
+            _extra_kwargs={
+                "azure_ad_token_provider": azure_ad_token_provider or self._azure_ad_token_provider,
+                **_extra_kwargs,
+            },
+        )
+
+    with_options = copy
+
+    async def _get_azure_ad_token(self) -> str | None:
+        provider = self._azure_ad_token_provider
+        if provider is not None:
+            token = provider()
+            if inspect.isawaitable(token):
+                token = await token
+            if not token or not isinstance(cast(Any, token), str):
+                raise ValueError(
+                    f"Expected `azure_ad_token_provider` argument to return a string but it returned {token}",
+                )
+            return str(token)
+
+        return None
+
+    @override
+    async def _prepare_options(self, options: FinalRequestOptions) -> FinalRequestOptions:
+        headers: dict[str, str | Omit] = {**options.headers} if is_given(options.headers) else {}
+
+        options = model_copy(options)
+        options.headers = headers
+
+        azure_ad_token = await self._get_azure_ad_token()
+        if azure_ad_token is not None:
+            if headers.get("Authorization") is None:
+                headers["Authorization"] = f"Bearer {azure_ad_token}"
+        elif self.api_key is not None:
+            assert self.api_key is not None
+            if headers.get("api-key") is None:
+                headers["api-key"] = self.api_key
+        else:
+            # should never be hit
+            raise ValueError("Unable to handle auth")
+
+        return options

anthropic/resources/beta/messages/messages.py

@@ -1076,9 +1076,9 @@ class Messages(SyncAPIResource):
 
         betas = [beta for beta in betas] if is_given(betas) else []
 
-        if "structured-outputs-2025-09-17" not in betas:
+        if "structured-outputs-2025-11-13" not in betas:
             # Ensure structured outputs beta is included for parse method
-            betas.append("structured-outputs-2025-09-17")
+            betas.append("structured-outputs-2025-11-13")
 
         extra_headers = {
             "X-Stainless-Helper": "beta.messages.parse",
@@ -2688,9 +2688,9 @@ class AsyncMessages(AsyncAPIResource):
             )
         betas = [beta for beta in betas] if is_given(betas) else []
 
-        if "structured-outputs-2025-09-17" not in betas:
+        if "structured-outputs-2025-11-13" not in betas:
             # Ensure structured outputs beta is included for parse method
-            betas.append("structured-outputs-2025-09-17")
+            betas.append("structured-outputs-2025-11-13")
 
         extra_headers = {
             "X-Stainless-Helper": "beta.messages.parse",

{anthropic-0.73.0.dist-info → anthropic-0.74.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: anthropic
-Version: 0.73.0
+Version: 0.74.1
 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.73.0.dist-info → anthropic-0.74.1.dist-info}/RECORD

@@ -1,6 +1,6 @@
-anthropic/__init__.py,sha256=rppe09RSa1Lpxfa6FsTQuwOA0Y8XDaICjtgWwncpnLA,3057
+anthropic/__init__.py,sha256=xp5IG2sv6wh0O6u-pJN8g3PJkQHfs2qIfU20muCRyj8,3167
 anthropic/_base_client.py,sha256=Ca5ANeCg2kvkN3Ego42boLcHIhj9npORXzh3VGQs1tw,72929
-anthropic/_client.py,sha256=M90bE_o_HRuBNrbA-D-grLZua841_5NTkzeUQpyE75Y,22812
+anthropic/_client.py,sha256=_BM__6VgtQZZCkWMGv6z58yTESUDtQVt2QWZIy_ya7U,23030
 anthropic/_compat.py,sha256=t3bXgTygusFSjp0qoTb9D6E749djY0tFAwHMgKEE-Rw,6775
 anthropic/_constants.py,sha256=wADeUqY3lsseF0L6jIen-PexfQ06FOtf2dVESXDM828,885
 anthropic/_exceptions.py,sha256=bkSqVWxtRdRb31H7MIvtxfh5mo_Xf7Ib3nPTOmAOmGs,4073
@@ -12,7 +12,7 @@ anthropic/_resource.py,sha256=FYEOzfhB-XWTR2gyTmQuuFoecRiVXxe_SpjZlQQGytU,1080
 anthropic/_response.py,sha256=1Y7-OrGn1lOwvZ_SmMlwT9Nb2i9A1RYw2Q4-F1cwPSU,30542
 anthropic/_streaming.py,sha256=AVgSkkvKHZsFD4xQbkOi9Oi0vkHoEZbkccyUw5yIxmA,14072
 anthropic/_types.py,sha256=vEab5B5Hp7xQQafVrgSCHeEPUmf74jofqIPo-n7Xljk,7338
-anthropic/_version.py,sha256=BLfER8BI7EhiCmW-EJcMjRIx012RjifoyJ7qwdyvum8,162
+anthropic/_version.py,sha256=RYabrekg643fRS1GXAocPuIMGw1-85RFzoldGyJ7Sxs,162
 anthropic/pagination.py,sha256=MgGFbx3GDm4XASijWas0-2eVb1iGR-DgqyPrDf5Jll8,5152
 anthropic/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 anthropic/_decoders/jsonl.py,sha256=KDLw-Frjo7gRup5qDp_BWkXIZ-mFZU5vFDz0WBhEKcs,3510
@@ -31,7 +31,9 @@ anthropic/_utils/_typing.py,sha256=N_5PPuFNsaygbtA_npZd98SVN1LQQvFTKL6bkWPBZGU,4
 anthropic/_utils/_utils.py,sha256=ugfUaneOK7I8h9b3656flwf5u_kthY0gvNuqvgOLoSU,12252
 anthropic/lib/.keep,sha256=wuNrz-5SXo3jJaJOJgz4vFHM41YH_g20F5cRQo0vLes,224
 anthropic/lib/__init__.py,sha256=ed3VXosCln6iXSojwutNZjzjoIVpDLIHfMiiMiSHjlU,99
-anthropic/lib/_files.py,sha256=7gggVMi-rWE-42gElwl7nncy3Gf_V62Ga6cIln_yG_M,1209
+anthropic/lib/_files.py,sha256=gVtOWR-evsIJV_HCX225tPRU6Dyj73FWXb7OPt5CVcQ,1221
+anthropic/lib/foundry.md,sha256=jFWVnP5a8qARzQjUdtvxhF1p2pkPo2WCRfkumhvdlZw,2745
+anthropic/lib/foundry.py,sha256=q4fZOnbBcBWFE_fVwL9EyJBFt-RFk0l78bzFxyO9Q2k,17537
 anthropic/lib/_extras/__init__.py,sha256=a9HX69-V9nROM4Em9a4y-xZTgiLE2jdlCyC6ZKtxfyY,53
 anthropic/lib/_extras/_common.py,sha256=IhHjAsirY2xfLJrzlt9rS_0IPsTJeWqKA2HWUuvDN14,348
 anthropic/lib/_extras/_google_auth.py,sha256=Wukh6VOgcDRYSsFCVT9tx_oXI1ApIsmioSLEMsYvDfw,688
@@ -67,7 +69,7 @@ anthropic/resources/beta/files.py,sha256=rz2seKKOcoF0ebUMEMF86LoPWi1YqK2zp-dMQ7t
 anthropic/resources/beta/models.py,sha256=1bPko6YIziXlKj9GWnAxReEoWIT_7TwBpU_oCUMhBlo,12516
 anthropic/resources/beta/messages/__init__.py,sha256=7ZO4hB7hPBhXQja7gMzkwLXQVDlyap4JsihpA0UKZjk,849
 anthropic/resources/beta/messages/batches.py,sha256=51m83Ijs6cIE_f4hRQNhSyNqDj5TVt0F0Bm4ryekoLw,36116
-anthropic/resources/beta/messages/messages.py,sha256=OPTTYEaPMx31_vHXsjkt9cvPXpKNTa-G1jt_iK98phc,151689
+anthropic/resources/beta/messages/messages.py,sha256=tnm8ra108AC1AjQ2neWCFHbdYVQPU3_J1aKSWemjAVI,151689
 anthropic/resources/beta/skills/__init__.py,sha256=QMC_HEzfI-k0jhfKJThUUjf9wf7Vs8HTxSXYNnvVx2o,836
 anthropic/resources/beta/skills/skills.py,sha256=ytCR9JN7Qgn9GbWT0oBgpy-nvYXWwqoBvOzZ_iURANE,25036
 anthropic/resources/beta/skills/versions.py,sha256=iWSrZ4iqVGm16f7r_aE79gDxeUTUaSw5dEBAyHIxRu8,25212
@@ -411,7 +413,7 @@ anthropic/types/shared/not_found_error.py,sha256=R6OsCvAmsf_SB2TwoX6E63o049qZMaA
 anthropic/types/shared/overloaded_error.py,sha256=PlyhHt3wmzcnynSfkWbfP4XkLoWsPa9B39V3CyAdgx8,282
 anthropic/types/shared/permission_error.py,sha256=nuyxtLXOiEkYEbFRXiAWjxU6XtdyjkAaXQ2NgMB3pjw,282
 anthropic/types/shared/rate_limit_error.py,sha256=eYULATjXa6KKdqeBauest7RzuN-bhGsY5BWwH9eYv4c,280
-anthropic-0.73.0.dist-info/METADATA,sha256=BOMTTUbACjvJH9v6O9RAUEY3RgkH12gkbN5vRHAGeI8,28514
-anthropic-0.73.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-anthropic-0.73.0.dist-info/licenses/LICENSE,sha256=i_lphP-Lz65-SMrnalKeiiUxe6ngKr9_08xk_flWV6Y,1056
-anthropic-0.73.0.dist-info/RECORD,,
+anthropic-0.74.1.dist-info/METADATA,sha256=hj9E86URKPzwsGvQYSWbc106lywLRwyc6x-_TMkFtkU,28514
+anthropic-0.74.1.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+anthropic-0.74.1.dist-info/licenses/LICENSE,sha256=i_lphP-Lz65-SMrnalKeiiUxe6ngKr9_08xk_flWV6Y,1056
+anthropic-0.74.1.dist-info/RECORD,,