feat(phase1): add image storage utilities

- Create backend/services/image_storage.py with 4 core functions:
  - sanitize_filename(): remove unsafe chars, limit to 255 chars, convert to lowercase
  - get_unique_filename(): handle collisions with UUID suffix (format: {name}_{uuid8}_{variant}.jpg)
  - ensure_image_directories(): create /images/ root and category subdirs on startup
  - save_image(): save bytes to /images/{category}/{filename}, returns relative path
- Create comprehensive test suite (22 tests) covering all functionality
- Integrate ensure_image_directories() into FastAPI startup event
- Directory structure: /images/{category}/{filename}
- Collision handling: auto-suffix with UUID if filename exists
- All tests passing, pathlib.Path for safe operations

venv/lib/python3.12/site-packages/anthropic/resources/beta/__init__.py

@@ -0,0 +1,145 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .beta import (
+    Beta,
+    AsyncBeta,
+    BetaWithRawResponse,
+    AsyncBetaWithRawResponse,
+    BetaWithStreamingResponse,
+    AsyncBetaWithStreamingResponse,
+)
+from .files import (
+    Files,
+    AsyncFiles,
+    FilesWithRawResponse,
+    AsyncFilesWithRawResponse,
+    FilesWithStreamingResponse,
+    AsyncFilesWithStreamingResponse,
+)
+from .agents import (
+    Agents,
+    AsyncAgents,
+    AgentsWithRawResponse,
+    AsyncAgentsWithRawResponse,
+    AgentsWithStreamingResponse,
+    AsyncAgentsWithStreamingResponse,
+)
+from .models import (
+    Models,
+    AsyncModels,
+    ModelsWithRawResponse,
+    AsyncModelsWithRawResponse,
+    ModelsWithStreamingResponse,
+    AsyncModelsWithStreamingResponse,
+)
+from .skills import (
+    Skills,
+    AsyncSkills,
+    SkillsWithRawResponse,
+    AsyncSkillsWithRawResponse,
+    SkillsWithStreamingResponse,
+    AsyncSkillsWithStreamingResponse,
+)
+from .vaults import (
+    Vaults,
+    AsyncVaults,
+    VaultsWithRawResponse,
+    AsyncVaultsWithRawResponse,
+    VaultsWithStreamingResponse,
+    AsyncVaultsWithStreamingResponse,
+)
+from .messages import (
+    Messages,
+    AsyncMessages,
+    MessagesWithRawResponse,
+    AsyncMessagesWithRawResponse,
+    MessagesWithStreamingResponse,
+    AsyncMessagesWithStreamingResponse,
+)
+from .sessions import (
+    Sessions,
+    AsyncSessions,
+    SessionsWithRawResponse,
+    AsyncSessionsWithRawResponse,
+    SessionsWithStreamingResponse,
+    AsyncSessionsWithStreamingResponse,
+)
+from .environments import (
+    Environments,
+    AsyncEnvironments,
+    EnvironmentsWithRawResponse,
+    AsyncEnvironmentsWithRawResponse,
+    EnvironmentsWithStreamingResponse,
+    AsyncEnvironmentsWithStreamingResponse,
+)
+from .user_profiles import (
+    UserProfiles,
+    AsyncUserProfiles,
+    UserProfilesWithRawResponse,
+    AsyncUserProfilesWithRawResponse,
+    UserProfilesWithStreamingResponse,
+    AsyncUserProfilesWithStreamingResponse,
+)
+
+__all__ = [
+    "Models",
+    "AsyncModels",
+    "ModelsWithRawResponse",
+    "AsyncModelsWithRawResponse",
+    "ModelsWithStreamingResponse",
+    "AsyncModelsWithStreamingResponse",
+    "Messages",
+    "AsyncMessages",
+    "MessagesWithRawResponse",
+    "AsyncMessagesWithRawResponse",
+    "MessagesWithStreamingResponse",
+    "AsyncMessagesWithStreamingResponse",
+    "Agents",
+    "AsyncAgents",
+    "AgentsWithRawResponse",
+    "AsyncAgentsWithRawResponse",
+    "AgentsWithStreamingResponse",
+    "AsyncAgentsWithStreamingResponse",
+    "Environments",
+    "AsyncEnvironments",
+    "EnvironmentsWithRawResponse",
+    "AsyncEnvironmentsWithRawResponse",
+    "EnvironmentsWithStreamingResponse",
+    "AsyncEnvironmentsWithStreamingResponse",
+    "Sessions",
+    "AsyncSessions",
+    "SessionsWithRawResponse",
+    "AsyncSessionsWithRawResponse",
+    "SessionsWithStreamingResponse",
+    "AsyncSessionsWithStreamingResponse",
+    "Vaults",
+    "AsyncVaults",
+    "VaultsWithRawResponse",
+    "AsyncVaultsWithRawResponse",
+    "VaultsWithStreamingResponse",
+    "AsyncVaultsWithStreamingResponse",
+    "Files",
+    "AsyncFiles",
+    "FilesWithRawResponse",
+    "AsyncFilesWithRawResponse",
+    "FilesWithStreamingResponse",
+    "AsyncFilesWithStreamingResponse",
+    "Skills",
+    "AsyncSkills",
+    "SkillsWithRawResponse",
+    "AsyncSkillsWithRawResponse",
+    "SkillsWithStreamingResponse",
+    "AsyncSkillsWithStreamingResponse",
+    "UserProfiles",
+    "AsyncUserProfiles",
+    "UserProfilesWithRawResponse",
+    "AsyncUserProfilesWithRawResponse",
+    "UserProfilesWithStreamingResponse",
+    "AsyncUserProfilesWithStreamingResponse",
+    "Beta",
+    "AsyncBeta",
+    "BetaWithRawResponse",
+    "AsyncBetaWithRawResponse",
+    "BetaWithStreamingResponse",
+    "AsyncBetaWithStreamingResponse",
+]

venv/lib/python3.12/site-packages/anthropic/resources/beta/agents/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .agents import (
+    Agents,
+    AsyncAgents,
+    AgentsWithRawResponse,
+    AsyncAgentsWithRawResponse,
+    AgentsWithStreamingResponse,
+    AsyncAgentsWithStreamingResponse,
+)
+from .versions import (
+    Versions,
+    AsyncVersions,
+    VersionsWithRawResponse,
+    AsyncVersionsWithRawResponse,
+    VersionsWithStreamingResponse,
+    AsyncVersionsWithStreamingResponse,
+)
+
+__all__ = [
+    "Versions",
+    "AsyncVersions",
+    "VersionsWithRawResponse",
+    "AsyncVersionsWithRawResponse",
+    "VersionsWithStreamingResponse",
+    "AsyncVersionsWithStreamingResponse",
+    "Agents",
+    "AsyncAgents",
+    "AgentsWithRawResponse",
+    "AsyncAgentsWithRawResponse",
+    "AgentsWithStreamingResponse",
+    "AsyncAgentsWithStreamingResponse",
+]

venv/lib/python3.12/site-packages/anthropic/resources/beta/agents/agents.py

@@ -0,0 +1,913 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, List, Union, Iterable, Optional
+from datetime import datetime
+from itertools import chain
+
+import httpx
+
+from .... import _legacy_response
+from .versions import (
+    Versions,
+    AsyncVersions,
+    VersionsWithRawResponse,
+    AsyncVersionsWithRawResponse,
+    VersionsWithStreamingResponse,
+    AsyncVersionsWithStreamingResponse,
+)
+from ...._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ...._utils import is_given, path_template, maybe_transform, strip_not_given, async_maybe_transform
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ....pagination import SyncPageCursor, AsyncPageCursor
+from ....types.beta import agent_list_params, agent_create_params, agent_update_params, agent_retrieve_params
+from ...._base_client import AsyncPaginator, make_request_options
+from ....types.anthropic_beta_param import AnthropicBetaParam
+from ....types.beta.beta_managed_agents_agent import BetaManagedAgentsAgent
+from ....types.beta.beta_managed_agents_skill_params import BetaManagedAgentsSkillParams
+from ....types.beta.beta_managed_agents_url_mcp_server_params import BetaManagedAgentsURLMCPServerParams
+
+__all__ = ["Agents", "AsyncAgents"]
+
+
+class Agents(SyncAPIResource):
+    @cached_property
+    def versions(self) -> Versions:
+        return Versions(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AgentsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AgentsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AgentsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return AgentsWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        model: agent_create_params.Model,
+        name: str,
+        description: Optional[str] | Omit = omit,
+        mcp_servers: Iterable[BetaManagedAgentsURLMCPServerParams] | Omit = omit,
+        metadata: Dict[str, str] | Omit = omit,
+        skills: Iterable[BetaManagedAgentsSkillParams] | Omit = omit,
+        system: Optional[str] | Omit = omit,
+        tools: Iterable[agent_create_params.Tool] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsAgent:
+        """Create Agent
+
+        Args:
+          model: Model identifier.
+
+        Accepts the
+              [model string](https://platform.claude.com/docs/en/about-claude/models/overview#latest-models-comparison),
+              e.g. `claude-opus-4-6`, or a `model_config` object for additional configuration
+              control
+
+          name: Human-readable name for the agent. 1-256 characters.
+
+          description: Description of what the agent does. Up to 2048 characters.
+
+          mcp_servers: MCP servers this agent connects to. Maximum 20. Names must be unique within the
+              array.
+
+          metadata: Arbitrary key-value metadata. Maximum 16 pairs, keys up to 64 chars, values up
+              to 512 chars.
+
+          skills: Skills available to the agent. Maximum 20.
+
+          system: System prompt for the agent. Up to 100,000 characters.
+
+          tools: Tool configurations available to the agent. Maximum of 128 tools across all
+              toolsets allowed.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._post(
+            "/v1/agents?beta=true",
+            body=maybe_transform(
+                {
+                    "model": model,
+                    "name": name,
+                    "description": description,
+                    "mcp_servers": mcp_servers,
+                    "metadata": metadata,
+                    "skills": skills,
+                    "system": system,
+                    "tools": tools,
+                },
+                agent_create_params.AgentCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsAgent,
+        )
+
+    def retrieve(
+        self,
+        agent_id: str,
+        *,
+        version: int | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsAgent:
+        """Get Agent
+
+        Args:
+          version: Agent version.
+
+        Omit for the most recent version. Must be at least 1 if
+              specified.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not agent_id:
+            raise ValueError(f"Expected a non-empty value for `agent_id` but received {agent_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._get(
+            path_template("/v1/agents/{agent_id}?beta=true", agent_id=agent_id),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"version": version}, agent_retrieve_params.AgentRetrieveParams),
+            ),
+            cast_to=BetaManagedAgentsAgent,
+        )
+
+    def update(
+        self,
+        agent_id: str,
+        *,
+        version: int,
+        description: Optional[str] | Omit = omit,
+        mcp_servers: Optional[Iterable[BetaManagedAgentsURLMCPServerParams]] | Omit = omit,
+        metadata: Optional[Dict[str, Optional[str]]] | Omit = omit,
+        model: agent_update_params.Model | Omit = omit,
+        name: str | Omit = omit,
+        skills: Optional[Iterable[BetaManagedAgentsSkillParams]] | Omit = omit,
+        system: Optional[str] | Omit = omit,
+        tools: Optional[Iterable[agent_update_params.Tool]] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsAgent:
+        """
+        Update Agent
+
+        Args:
+          version: The agent's current version, used to prevent concurrent overwrites. Obtain this
+              value from a create or retrieve response. The request fails if this does not
+              match the server's current version.
+
+          description: Description. Up to 2048 characters. Omit to preserve; send empty string or null
+              to clear.
+
+          mcp_servers: MCP servers. Full replacement. Omit to preserve; send empty array or null to
+              clear. Names must be unique. Maximum 20.
+
+          metadata: Metadata patch. Set a key to a string to upsert it, or to null to delete it.
+              Omit the field to preserve. The stored bag is limited to 16 keys (up to 64 chars
+              each) with values up to 512 chars.
+
+          model: Model identifier. Accepts the
+              [model string](https://platform.claude.com/docs/en/about-claude/models/overview#latest-models-comparison),
+              e.g. `claude-opus-4-6`, or a `model_config` object for additional configuration
+              control. Omit to preserve. Cannot be cleared.
+
+          name: Human-readable name. 1-256 characters. Omit to preserve. Cannot be cleared.
+
+          skills: Skills. Full replacement. Omit to preserve; send empty array or null to clear.
+              Maximum 20.
+
+          system: System prompt. Up to 100,000 characters. Omit to preserve; send empty string or
+              null to clear.
+
+          tools: Tool configurations available to the agent. Full replacement. Omit to preserve;
+              send empty array or null to clear. Maximum of 128 tools across all toolsets
+              allowed.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not agent_id:
+            raise ValueError(f"Expected a non-empty value for `agent_id` but received {agent_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._post(
+            path_template("/v1/agents/{agent_id}?beta=true", agent_id=agent_id),
+            body=maybe_transform(
+                {
+                    "version": version,
+                    "description": description,
+                    "mcp_servers": mcp_servers,
+                    "metadata": metadata,
+                    "model": model,
+                    "name": name,
+                    "skills": skills,
+                    "system": system,
+                    "tools": tools,
+                },
+                agent_update_params.AgentUpdateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsAgent,
+        )
+
+    def list(
+        self,
+        *,
+        created_at_gte: Union[str, datetime] | Omit = omit,
+        created_at_lte: Union[str, datetime] | Omit = omit,
+        include_archived: bool | Omit = omit,
+        limit: int | Omit = omit,
+        page: str | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncPageCursor[BetaManagedAgentsAgent]:
+        """
+        List Agents
+
+        Args:
+          created_at_gte: Return agents created at or after this time (inclusive).
+
+          created_at_lte: Return agents created at or before this time (inclusive).
+
+          include_archived: Include archived agents in results. Defaults to false.
+
+          limit: Maximum results per page. Default 20, maximum 100.
+
+          page: Opaque pagination cursor from a previous response.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._get_api_list(
+            "/v1/agents?beta=true",
+            page=SyncPageCursor[BetaManagedAgentsAgent],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "created_at_gte": created_at_gte,
+                        "created_at_lte": created_at_lte,
+                        "include_archived": include_archived,
+                        "limit": limit,
+                        "page": page,
+                    },
+                    agent_list_params.AgentListParams,
+                ),
+            ),
+            model=BetaManagedAgentsAgent,
+        )
+
+    def archive(
+        self,
+        agent_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsAgent:
+        """
+        Archive Agent
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not agent_id:
+            raise ValueError(f"Expected a non-empty value for `agent_id` but received {agent_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._post(
+            path_template("/v1/agents/{agent_id}/archive?beta=true", agent_id=agent_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsAgent,
+        )
+
+
+class AsyncAgents(AsyncAPIResource):
+    @cached_property
+    def versions(self) -> AsyncVersions:
+        return AsyncVersions(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncAgentsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncAgentsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncAgentsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return AsyncAgentsWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        model: agent_create_params.Model,
+        name: str,
+        description: Optional[str] | Omit = omit,
+        mcp_servers: Iterable[BetaManagedAgentsURLMCPServerParams] | Omit = omit,
+        metadata: Dict[str, str] | Omit = omit,
+        skills: Iterable[BetaManagedAgentsSkillParams] | Omit = omit,
+        system: Optional[str] | Omit = omit,
+        tools: Iterable[agent_create_params.Tool] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsAgent:
+        """Create Agent
+
+        Args:
+          model: Model identifier.
+
+        Accepts the
+              [model string](https://platform.claude.com/docs/en/about-claude/models/overview#latest-models-comparison),
+              e.g. `claude-opus-4-6`, or a `model_config` object for additional configuration
+              control
+
+          name: Human-readable name for the agent. 1-256 characters.
+
+          description: Description of what the agent does. Up to 2048 characters.
+
+          mcp_servers: MCP servers this agent connects to. Maximum 20. Names must be unique within the
+              array.
+
+          metadata: Arbitrary key-value metadata. Maximum 16 pairs, keys up to 64 chars, values up
+              to 512 chars.
+
+          skills: Skills available to the agent. Maximum 20.
+
+          system: System prompt for the agent. Up to 100,000 characters.
+
+          tools: Tool configurations available to the agent. Maximum of 128 tools across all
+              toolsets allowed.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._post(
+            "/v1/agents?beta=true",
+            body=await async_maybe_transform(
+                {
+                    "model": model,
+                    "name": name,
+                    "description": description,
+                    "mcp_servers": mcp_servers,
+                    "metadata": metadata,
+                    "skills": skills,
+                    "system": system,
+                    "tools": tools,
+                },
+                agent_create_params.AgentCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsAgent,
+        )
+
+    async def retrieve(
+        self,
+        agent_id: str,
+        *,
+        version: int | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsAgent:
+        """Get Agent
+
+        Args:
+          version: Agent version.
+
+        Omit for the most recent version. Must be at least 1 if
+              specified.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not agent_id:
+            raise ValueError(f"Expected a non-empty value for `agent_id` but received {agent_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._get(
+            path_template("/v1/agents/{agent_id}?beta=true", agent_id=agent_id),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform({"version": version}, agent_retrieve_params.AgentRetrieveParams),
+            ),
+            cast_to=BetaManagedAgentsAgent,
+        )
+
+    async def update(
+        self,
+        agent_id: str,
+        *,
+        version: int,
+        description: Optional[str] | Omit = omit,
+        mcp_servers: Optional[Iterable[BetaManagedAgentsURLMCPServerParams]] | Omit = omit,
+        metadata: Optional[Dict[str, Optional[str]]] | Omit = omit,
+        model: agent_update_params.Model | Omit = omit,
+        name: str | Omit = omit,
+        skills: Optional[Iterable[BetaManagedAgentsSkillParams]] | Omit = omit,
+        system: Optional[str] | Omit = omit,
+        tools: Optional[Iterable[agent_update_params.Tool]] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsAgent:
+        """
+        Update Agent
+
+        Args:
+          version: The agent's current version, used to prevent concurrent overwrites. Obtain this
+              value from a create or retrieve response. The request fails if this does not
+              match the server's current version.
+
+          description: Description. Up to 2048 characters. Omit to preserve; send empty string or null
+              to clear.
+
+          mcp_servers: MCP servers. Full replacement. Omit to preserve; send empty array or null to
+              clear. Names must be unique. Maximum 20.
+
+          metadata: Metadata patch. Set a key to a string to upsert it, or to null to delete it.
+              Omit the field to preserve. The stored bag is limited to 16 keys (up to 64 chars
+              each) with values up to 512 chars.
+
+          model: Model identifier. Accepts the
+              [model string](https://platform.claude.com/docs/en/about-claude/models/overview#latest-models-comparison),
+              e.g. `claude-opus-4-6`, or a `model_config` object for additional configuration
+              control. Omit to preserve. Cannot be cleared.
+
+          name: Human-readable name. 1-256 characters. Omit to preserve. Cannot be cleared.
+
+          skills: Skills. Full replacement. Omit to preserve; send empty array or null to clear.
+              Maximum 20.
+
+          system: System prompt. Up to 100,000 characters. Omit to preserve; send empty string or
+              null to clear.
+
+          tools: Tool configurations available to the agent. Full replacement. Omit to preserve;
+              send empty array or null to clear. Maximum of 128 tools across all toolsets
+              allowed.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not agent_id:
+            raise ValueError(f"Expected a non-empty value for `agent_id` but received {agent_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._post(
+            path_template("/v1/agents/{agent_id}?beta=true", agent_id=agent_id),
+            body=await async_maybe_transform(
+                {
+                    "version": version,
+                    "description": description,
+                    "mcp_servers": mcp_servers,
+                    "metadata": metadata,
+                    "model": model,
+                    "name": name,
+                    "skills": skills,
+                    "system": system,
+                    "tools": tools,
+                },
+                agent_update_params.AgentUpdateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsAgent,
+        )
+
+    def list(
+        self,
+        *,
+        created_at_gte: Union[str, datetime] | Omit = omit,
+        created_at_lte: Union[str, datetime] | Omit = omit,
+        include_archived: bool | Omit = omit,
+        limit: int | Omit = omit,
+        page: str | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[BetaManagedAgentsAgent, AsyncPageCursor[BetaManagedAgentsAgent]]:
+        """
+        List Agents
+
+        Args:
+          created_at_gte: Return agents created at or after this time (inclusive).
+
+          created_at_lte: Return agents created at or before this time (inclusive).
+
+          include_archived: Include archived agents in results. Defaults to false.
+
+          limit: Maximum results per page. Default 20, maximum 100.
+
+          page: Opaque pagination cursor from a previous response.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._get_api_list(
+            "/v1/agents?beta=true",
+            page=AsyncPageCursor[BetaManagedAgentsAgent],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "created_at_gte": created_at_gte,
+                        "created_at_lte": created_at_lte,
+                        "include_archived": include_archived,
+                        "limit": limit,
+                        "page": page,
+                    },
+                    agent_list_params.AgentListParams,
+                ),
+            ),
+            model=BetaManagedAgentsAgent,
+        )
+
+    async def archive(
+        self,
+        agent_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsAgent:
+        """
+        Archive Agent
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not agent_id:
+            raise ValueError(f"Expected a non-empty value for `agent_id` but received {agent_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._post(
+            path_template("/v1/agents/{agent_id}/archive?beta=true", agent_id=agent_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsAgent,
+        )
+
+
+class AgentsWithRawResponse:
+    def __init__(self, agents: Agents) -> None:
+        self._agents = agents
+
+        self.create = _legacy_response.to_raw_response_wrapper(
+            agents.create,
+        )
+        self.retrieve = _legacy_response.to_raw_response_wrapper(
+            agents.retrieve,
+        )
+        self.update = _legacy_response.to_raw_response_wrapper(
+            agents.update,
+        )
+        self.list = _legacy_response.to_raw_response_wrapper(
+            agents.list,
+        )
+        self.archive = _legacy_response.to_raw_response_wrapper(
+            agents.archive,
+        )
+
+    @cached_property
+    def versions(self) -> VersionsWithRawResponse:
+        return VersionsWithRawResponse(self._agents.versions)
+
+
+class AsyncAgentsWithRawResponse:
+    def __init__(self, agents: AsyncAgents) -> None:
+        self._agents = agents
+
+        self.create = _legacy_response.async_to_raw_response_wrapper(
+            agents.create,
+        )
+        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
+            agents.retrieve,
+        )
+        self.update = _legacy_response.async_to_raw_response_wrapper(
+            agents.update,
+        )
+        self.list = _legacy_response.async_to_raw_response_wrapper(
+            agents.list,
+        )
+        self.archive = _legacy_response.async_to_raw_response_wrapper(
+            agents.archive,
+        )
+
+    @cached_property
+    def versions(self) -> AsyncVersionsWithRawResponse:
+        return AsyncVersionsWithRawResponse(self._agents.versions)
+
+
+class AgentsWithStreamingResponse:
+    def __init__(self, agents: Agents) -> None:
+        self._agents = agents
+
+        self.create = to_streamed_response_wrapper(
+            agents.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            agents.retrieve,
+        )
+        self.update = to_streamed_response_wrapper(
+            agents.update,
+        )
+        self.list = to_streamed_response_wrapper(
+            agents.list,
+        )
+        self.archive = to_streamed_response_wrapper(
+            agents.archive,
+        )
+
+    @cached_property
+    def versions(self) -> VersionsWithStreamingResponse:
+        return VersionsWithStreamingResponse(self._agents.versions)
+
+
+class AsyncAgentsWithStreamingResponse:
+    def __init__(self, agents: AsyncAgents) -> None:
+        self._agents = agents
+
+        self.create = async_to_streamed_response_wrapper(
+            agents.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            agents.retrieve,
+        )
+        self.update = async_to_streamed_response_wrapper(
+            agents.update,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            agents.list,
+        )
+        self.archive = async_to_streamed_response_wrapper(
+            agents.archive,
+        )
+
+    @cached_property
+    def versions(self) -> AsyncVersionsWithStreamingResponse:
+        return AsyncVersionsWithStreamingResponse(self._agents.versions)

venv/lib/python3.12/site-packages/anthropic/resources/beta/agents/versions.py

@@ -0,0 +1,230 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from itertools import chain
+
+import httpx
+
+from .... import _legacy_response
+from ...._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ...._utils import is_given, path_template, maybe_transform, strip_not_given
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ....pagination import SyncPageCursor, AsyncPageCursor
+from ...._base_client import AsyncPaginator, make_request_options
+from ....types.beta.agents import version_list_params
+from ....types.anthropic_beta_param import AnthropicBetaParam
+from ....types.beta.beta_managed_agents_agent import BetaManagedAgentsAgent
+
+__all__ = ["Versions", "AsyncVersions"]
+
+
+class Versions(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> VersionsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return VersionsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> VersionsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return VersionsWithStreamingResponse(self)
+
+    def list(
+        self,
+        agent_id: str,
+        *,
+        limit: int | Omit = omit,
+        page: str | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncPageCursor[BetaManagedAgentsAgent]:
+        """List Agent Versions
+
+        Args:
+          limit: Maximum results per page.
+
+        Default 20, maximum 100.
+
+          page: Opaque pagination cursor.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not agent_id:
+            raise ValueError(f"Expected a non-empty value for `agent_id` but received {agent_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._get_api_list(
+            path_template("/v1/agents/{agent_id}/versions?beta=true", agent_id=agent_id),
+            page=SyncPageCursor[BetaManagedAgentsAgent],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "limit": limit,
+                        "page": page,
+                    },
+                    version_list_params.VersionListParams,
+                ),
+            ),
+            model=BetaManagedAgentsAgent,
+        )
+
+
+class AsyncVersions(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncVersionsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncVersionsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncVersionsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return AsyncVersionsWithStreamingResponse(self)
+
+    def list(
+        self,
+        agent_id: str,
+        *,
+        limit: int | Omit = omit,
+        page: str | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[BetaManagedAgentsAgent, AsyncPageCursor[BetaManagedAgentsAgent]]:
+        """List Agent Versions
+
+        Args:
+          limit: Maximum results per page.
+
+        Default 20, maximum 100.
+
+          page: Opaque pagination cursor.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not agent_id:
+            raise ValueError(f"Expected a non-empty value for `agent_id` but received {agent_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._get_api_list(
+            path_template("/v1/agents/{agent_id}/versions?beta=true", agent_id=agent_id),
+            page=AsyncPageCursor[BetaManagedAgentsAgent],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "limit": limit,
+                        "page": page,
+                    },
+                    version_list_params.VersionListParams,
+                ),
+            ),
+            model=BetaManagedAgentsAgent,
+        )
+
+
+class VersionsWithRawResponse:
+    def __init__(self, versions: Versions) -> None:
+        self._versions = versions
+
+        self.list = _legacy_response.to_raw_response_wrapper(
+            versions.list,
+        )
+
+
+class AsyncVersionsWithRawResponse:
+    def __init__(self, versions: AsyncVersions) -> None:
+        self._versions = versions
+
+        self.list = _legacy_response.async_to_raw_response_wrapper(
+            versions.list,
+        )
+
+
+class VersionsWithStreamingResponse:
+    def __init__(self, versions: Versions) -> None:
+        self._versions = versions
+
+        self.list = to_streamed_response_wrapper(
+            versions.list,
+        )
+
+
+class AsyncVersionsWithStreamingResponse:
+    def __init__(self, versions: AsyncVersions) -> None:
+        self._versions = versions
+
+        self.list = async_to_streamed_response_wrapper(
+            versions.list,
+        )

venv/lib/python3.12/site-packages/anthropic/resources/beta/beta.py

@@ -0,0 +1,358 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .files import (
+    Files,
+    AsyncFiles,
+    FilesWithRawResponse,
+    AsyncFilesWithRawResponse,
+    FilesWithStreamingResponse,
+    AsyncFilesWithStreamingResponse,
+)
+from .models import (
+    Models,
+    AsyncModels,
+    ModelsWithRawResponse,
+    AsyncModelsWithRawResponse,
+    ModelsWithStreamingResponse,
+    AsyncModelsWithStreamingResponse,
+)
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from .environments import (
+    Environments,
+    AsyncEnvironments,
+    EnvironmentsWithRawResponse,
+    AsyncEnvironmentsWithRawResponse,
+    EnvironmentsWithStreamingResponse,
+    AsyncEnvironmentsWithStreamingResponse,
+)
+from .agents.agents import (
+    Agents,
+    AsyncAgents,
+    AgentsWithRawResponse,
+    AsyncAgentsWithRawResponse,
+    AgentsWithStreamingResponse,
+    AsyncAgentsWithStreamingResponse,
+)
+from .skills.skills import (
+    Skills,
+    AsyncSkills,
+    SkillsWithRawResponse,
+    AsyncSkillsWithRawResponse,
+    SkillsWithStreamingResponse,
+    AsyncSkillsWithStreamingResponse,
+)
+from .user_profiles import (
+    UserProfiles,
+    AsyncUserProfiles,
+    UserProfilesWithRawResponse,
+    AsyncUserProfilesWithRawResponse,
+    UserProfilesWithStreamingResponse,
+    AsyncUserProfilesWithStreamingResponse,
+)
+from .vaults.vaults import (
+    Vaults,
+    AsyncVaults,
+    VaultsWithRawResponse,
+    AsyncVaultsWithRawResponse,
+    VaultsWithStreamingResponse,
+    AsyncVaultsWithStreamingResponse,
+)
+from .messages.messages import (
+    Messages,
+    AsyncMessages,
+    MessagesWithRawResponse,
+    AsyncMessagesWithRawResponse,
+    MessagesWithStreamingResponse,
+    AsyncMessagesWithStreamingResponse,
+)
+from .sessions.sessions import (
+    Sessions,
+    AsyncSessions,
+    SessionsWithRawResponse,
+    AsyncSessionsWithRawResponse,
+    SessionsWithStreamingResponse,
+    AsyncSessionsWithStreamingResponse,
+)
+
+__all__ = ["Beta", "AsyncBeta"]
+
+
+class Beta(SyncAPIResource):
+    @cached_property
+    def models(self) -> Models:
+        return Models(self._client)
+
+    @cached_property
+    def messages(self) -> Messages:
+        return Messages(self._client)
+
+    @cached_property
+    def agents(self) -> Agents:
+        return Agents(self._client)
+
+    @cached_property
+    def environments(self) -> Environments:
+        return Environments(self._client)
+
+    @cached_property
+    def sessions(self) -> Sessions:
+        return Sessions(self._client)
+
+    @cached_property
+    def vaults(self) -> Vaults:
+        return Vaults(self._client)
+
+    @cached_property
+    def files(self) -> Files:
+        return Files(self._client)
+
+    @cached_property
+    def skills(self) -> Skills:
+        return Skills(self._client)
+
+    @cached_property
+    def user_profiles(self) -> UserProfiles:
+        return UserProfiles(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> BetaWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return BetaWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> BetaWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return BetaWithStreamingResponse(self)
+
+
+class AsyncBeta(AsyncAPIResource):
+    @cached_property
+    def models(self) -> AsyncModels:
+        return AsyncModels(self._client)
+
+    @cached_property
+    def messages(self) -> AsyncMessages:
+        return AsyncMessages(self._client)
+
+    @cached_property
+    def agents(self) -> AsyncAgents:
+        return AsyncAgents(self._client)
+
+    @cached_property
+    def environments(self) -> AsyncEnvironments:
+        return AsyncEnvironments(self._client)
+
+    @cached_property
+    def sessions(self) -> AsyncSessions:
+        return AsyncSessions(self._client)
+
+    @cached_property
+    def vaults(self) -> AsyncVaults:
+        return AsyncVaults(self._client)
+
+    @cached_property
+    def files(self) -> AsyncFiles:
+        return AsyncFiles(self._client)
+
+    @cached_property
+    def skills(self) -> AsyncSkills:
+        return AsyncSkills(self._client)
+
+    @cached_property
+    def user_profiles(self) -> AsyncUserProfiles:
+        return AsyncUserProfiles(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncBetaWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncBetaWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncBetaWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return AsyncBetaWithStreamingResponse(self)
+
+
+class BetaWithRawResponse:
+    def __init__(self, beta: Beta) -> None:
+        self._beta = beta
+
+    @cached_property
+    def models(self) -> ModelsWithRawResponse:
+        return ModelsWithRawResponse(self._beta.models)
+
+    @cached_property
+    def messages(self) -> MessagesWithRawResponse:
+        return MessagesWithRawResponse(self._beta.messages)
+
+    @cached_property
+    def agents(self) -> AgentsWithRawResponse:
+        return AgentsWithRawResponse(self._beta.agents)
+
+    @cached_property
+    def environments(self) -> EnvironmentsWithRawResponse:
+        return EnvironmentsWithRawResponse(self._beta.environments)
+
+    @cached_property
+    def sessions(self) -> SessionsWithRawResponse:
+        return SessionsWithRawResponse(self._beta.sessions)
+
+    @cached_property
+    def vaults(self) -> VaultsWithRawResponse:
+        return VaultsWithRawResponse(self._beta.vaults)
+
+    @cached_property
+    def files(self) -> FilesWithRawResponse:
+        return FilesWithRawResponse(self._beta.files)
+
+    @cached_property
+    def skills(self) -> SkillsWithRawResponse:
+        return SkillsWithRawResponse(self._beta.skills)
+
+    @cached_property
+    def user_profiles(self) -> UserProfilesWithRawResponse:
+        return UserProfilesWithRawResponse(self._beta.user_profiles)
+
+
+class AsyncBetaWithRawResponse:
+    def __init__(self, beta: AsyncBeta) -> None:
+        self._beta = beta
+
+    @cached_property
+    def models(self) -> AsyncModelsWithRawResponse:
+        return AsyncModelsWithRawResponse(self._beta.models)
+
+    @cached_property
+    def messages(self) -> AsyncMessagesWithRawResponse:
+        return AsyncMessagesWithRawResponse(self._beta.messages)
+
+    @cached_property
+    def agents(self) -> AsyncAgentsWithRawResponse:
+        return AsyncAgentsWithRawResponse(self._beta.agents)
+
+    @cached_property
+    def environments(self) -> AsyncEnvironmentsWithRawResponse:
+        return AsyncEnvironmentsWithRawResponse(self._beta.environments)
+
+    @cached_property
+    def sessions(self) -> AsyncSessionsWithRawResponse:
+        return AsyncSessionsWithRawResponse(self._beta.sessions)
+
+    @cached_property
+    def vaults(self) -> AsyncVaultsWithRawResponse:
+        return AsyncVaultsWithRawResponse(self._beta.vaults)
+
+    @cached_property
+    def files(self) -> AsyncFilesWithRawResponse:
+        return AsyncFilesWithRawResponse(self._beta.files)
+
+    @cached_property
+    def skills(self) -> AsyncSkillsWithRawResponse:
+        return AsyncSkillsWithRawResponse(self._beta.skills)
+
+    @cached_property
+    def user_profiles(self) -> AsyncUserProfilesWithRawResponse:
+        return AsyncUserProfilesWithRawResponse(self._beta.user_profiles)
+
+
+class BetaWithStreamingResponse:
+    def __init__(self, beta: Beta) -> None:
+        self._beta = beta
+
+    @cached_property
+    def models(self) -> ModelsWithStreamingResponse:
+        return ModelsWithStreamingResponse(self._beta.models)
+
+    @cached_property
+    def messages(self) -> MessagesWithStreamingResponse:
+        return MessagesWithStreamingResponse(self._beta.messages)
+
+    @cached_property
+    def agents(self) -> AgentsWithStreamingResponse:
+        return AgentsWithStreamingResponse(self._beta.agents)
+
+    @cached_property
+    def environments(self) -> EnvironmentsWithStreamingResponse:
+        return EnvironmentsWithStreamingResponse(self._beta.environments)
+
+    @cached_property
+    def sessions(self) -> SessionsWithStreamingResponse:
+        return SessionsWithStreamingResponse(self._beta.sessions)
+
+    @cached_property
+    def vaults(self) -> VaultsWithStreamingResponse:
+        return VaultsWithStreamingResponse(self._beta.vaults)
+
+    @cached_property
+    def files(self) -> FilesWithStreamingResponse:
+        return FilesWithStreamingResponse(self._beta.files)
+
+    @cached_property
+    def skills(self) -> SkillsWithStreamingResponse:
+        return SkillsWithStreamingResponse(self._beta.skills)
+
+    @cached_property
+    def user_profiles(self) -> UserProfilesWithStreamingResponse:
+        return UserProfilesWithStreamingResponse(self._beta.user_profiles)
+
+
+class AsyncBetaWithStreamingResponse:
+    def __init__(self, beta: AsyncBeta) -> None:
+        self._beta = beta
+
+    @cached_property
+    def models(self) -> AsyncModelsWithStreamingResponse:
+        return AsyncModelsWithStreamingResponse(self._beta.models)
+
+    @cached_property
+    def messages(self) -> AsyncMessagesWithStreamingResponse:
+        return AsyncMessagesWithStreamingResponse(self._beta.messages)
+
+    @cached_property
+    def agents(self) -> AsyncAgentsWithStreamingResponse:
+        return AsyncAgentsWithStreamingResponse(self._beta.agents)
+
+    @cached_property
+    def environments(self) -> AsyncEnvironmentsWithStreamingResponse:
+        return AsyncEnvironmentsWithStreamingResponse(self._beta.environments)
+
+    @cached_property
+    def sessions(self) -> AsyncSessionsWithStreamingResponse:
+        return AsyncSessionsWithStreamingResponse(self._beta.sessions)
+
+    @cached_property
+    def vaults(self) -> AsyncVaultsWithStreamingResponse:
+        return AsyncVaultsWithStreamingResponse(self._beta.vaults)
+
+    @cached_property
+    def files(self) -> AsyncFilesWithStreamingResponse:
+        return AsyncFilesWithStreamingResponse(self._beta.files)
+
+    @cached_property
+    def skills(self) -> AsyncSkillsWithStreamingResponse:
+        return AsyncSkillsWithStreamingResponse(self._beta.skills)
+
+    @cached_property
+    def user_profiles(self) -> AsyncUserProfilesWithStreamingResponse:
+        return AsyncUserProfilesWithStreamingResponse(self._beta.user_profiles)

venv/lib/python3.12/site-packages/anthropic/resources/beta/environments.py

@@ -0,0 +1,863 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, List, Optional
+from itertools import chain
+
+import httpx
+
+from ... import _legacy_response
+from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ..._utils import is_given, path_template, maybe_transform, strip_not_given, async_maybe_transform
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from ..._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ...pagination import SyncPageCursor, AsyncPageCursor
+from ...types.beta import (
+    BetaCloudConfigParams,
+    environment_list_params,
+    environment_create_params,
+    environment_update_params,
+)
+from ..._base_client import AsyncPaginator, make_request_options
+from ...types.anthropic_beta_param import AnthropicBetaParam
+from ...types.beta.beta_environment import BetaEnvironment
+from ...types.beta.beta_cloud_config_params import BetaCloudConfigParams
+from ...types.beta.beta_environment_delete_response import BetaEnvironmentDeleteResponse
+
+__all__ = ["Environments", "AsyncEnvironments"]
+
+
+class Environments(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> EnvironmentsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return EnvironmentsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> EnvironmentsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return EnvironmentsWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        name: str,
+        config: Optional[BetaCloudConfigParams] | Omit = omit,
+        description: Optional[str] | Omit = omit,
+        metadata: Dict[str, str] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaEnvironment:
+        """
+        Create a new environment with the specified configuration.
+
+        Args:
+          name: Human-readable name for the environment
+
+          config: Request params for `cloud` environment configuration.
+
+              Fields default to null; on update, omitted fields preserve the existing value.
+
+          description: Optional description of the environment
+
+          metadata: User-provided metadata key-value pairs
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._post(
+            "/v1/environments?beta=true",
+            body=maybe_transform(
+                {
+                    "name": name,
+                    "config": config,
+                    "description": description,
+                    "metadata": metadata,
+                },
+                environment_create_params.EnvironmentCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaEnvironment,
+        )
+
+    def retrieve(
+        self,
+        environment_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaEnvironment:
+        """
+        Retrieve a specific environment by ID.
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not environment_id:
+            raise ValueError(f"Expected a non-empty value for `environment_id` but received {environment_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._get(
+            path_template("/v1/environments/{environment_id}?beta=true", environment_id=environment_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaEnvironment,
+        )
+
+    def update(
+        self,
+        environment_id: str,
+        *,
+        config: Optional[BetaCloudConfigParams] | Omit = omit,
+        description: Optional[str] | Omit = omit,
+        metadata: Dict[str, Optional[str]] | Omit = omit,
+        name: Optional[str] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaEnvironment:
+        """
+        Update an existing environment's configuration.
+
+        Args:
+          config: Request params for `cloud` environment configuration.
+
+              Fields default to null; on update, omitted fields preserve the existing value.
+
+          description: Updated description of the environment
+
+          metadata: User-provided metadata key-value pairs. Set a value to null or empty string to
+              delete the key.
+
+          name: Updated name for the environment
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not environment_id:
+            raise ValueError(f"Expected a non-empty value for `environment_id` but received {environment_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._post(
+            path_template("/v1/environments/{environment_id}?beta=true", environment_id=environment_id),
+            body=maybe_transform(
+                {
+                    "config": config,
+                    "description": description,
+                    "metadata": metadata,
+                    "name": name,
+                },
+                environment_update_params.EnvironmentUpdateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaEnvironment,
+        )
+
+    def list(
+        self,
+        *,
+        include_archived: bool | Omit = omit,
+        limit: int | Omit = omit,
+        page: Optional[str] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncPageCursor[BetaEnvironment]:
+        """
+        List environments with pagination support.
+
+        Args:
+          include_archived: Include archived environments in the response
+
+          limit: Maximum number of environments to return
+
+          page: Opaque cursor from previous response for pagination. Pass the `next_page` value
+              from the previous response.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._get_api_list(
+            "/v1/environments?beta=true",
+            page=SyncPageCursor[BetaEnvironment],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "include_archived": include_archived,
+                        "limit": limit,
+                        "page": page,
+                    },
+                    environment_list_params.EnvironmentListParams,
+                ),
+            ),
+            model=BetaEnvironment,
+        )
+
+    def delete(
+        self,
+        environment_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaEnvironmentDeleteResponse:
+        """Delete an environment by ID.
+
+        Returns a confirmation of the deletion.
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not environment_id:
+            raise ValueError(f"Expected a non-empty value for `environment_id` but received {environment_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._delete(
+            path_template("/v1/environments/{environment_id}?beta=true", environment_id=environment_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaEnvironmentDeleteResponse,
+        )
+
+    def archive(
+        self,
+        environment_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaEnvironment:
+        """Archive an environment by ID.
+
+        Archived environments cannot be used to create new
+        sessions.
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not environment_id:
+            raise ValueError(f"Expected a non-empty value for `environment_id` but received {environment_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._post(
+            path_template("/v1/environments/{environment_id}/archive?beta=true", environment_id=environment_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaEnvironment,
+        )
+
+
+class AsyncEnvironments(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncEnvironmentsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncEnvironmentsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncEnvironmentsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return AsyncEnvironmentsWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        name: str,
+        config: Optional[BetaCloudConfigParams] | Omit = omit,
+        description: Optional[str] | Omit = omit,
+        metadata: Dict[str, str] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaEnvironment:
+        """
+        Create a new environment with the specified configuration.
+
+        Args:
+          name: Human-readable name for the environment
+
+          config: Request params for `cloud` environment configuration.
+
+              Fields default to null; on update, omitted fields preserve the existing value.
+
+          description: Optional description of the environment
+
+          metadata: User-provided metadata key-value pairs
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._post(
+            "/v1/environments?beta=true",
+            body=await async_maybe_transform(
+                {
+                    "name": name,
+                    "config": config,
+                    "description": description,
+                    "metadata": metadata,
+                },
+                environment_create_params.EnvironmentCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaEnvironment,
+        )
+
+    async def retrieve(
+        self,
+        environment_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaEnvironment:
+        """
+        Retrieve a specific environment by ID.
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not environment_id:
+            raise ValueError(f"Expected a non-empty value for `environment_id` but received {environment_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._get(
+            path_template("/v1/environments/{environment_id}?beta=true", environment_id=environment_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaEnvironment,
+        )
+
+    async def update(
+        self,
+        environment_id: str,
+        *,
+        config: Optional[BetaCloudConfigParams] | Omit = omit,
+        description: Optional[str] | Omit = omit,
+        metadata: Dict[str, Optional[str]] | Omit = omit,
+        name: Optional[str] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaEnvironment:
+        """
+        Update an existing environment's configuration.
+
+        Args:
+          config: Request params for `cloud` environment configuration.
+
+              Fields default to null; on update, omitted fields preserve the existing value.
+
+          description: Updated description of the environment
+
+          metadata: User-provided metadata key-value pairs. Set a value to null or empty string to
+              delete the key.
+
+          name: Updated name for the environment
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not environment_id:
+            raise ValueError(f"Expected a non-empty value for `environment_id` but received {environment_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._post(
+            path_template("/v1/environments/{environment_id}?beta=true", environment_id=environment_id),
+            body=await async_maybe_transform(
+                {
+                    "config": config,
+                    "description": description,
+                    "metadata": metadata,
+                    "name": name,
+                },
+                environment_update_params.EnvironmentUpdateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaEnvironment,
+        )
+
+    def list(
+        self,
+        *,
+        include_archived: bool | Omit = omit,
+        limit: int | Omit = omit,
+        page: Optional[str] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[BetaEnvironment, AsyncPageCursor[BetaEnvironment]]:
+        """
+        List environments with pagination support.
+
+        Args:
+          include_archived: Include archived environments in the response
+
+          limit: Maximum number of environments to return
+
+          page: Opaque cursor from previous response for pagination. Pass the `next_page` value
+              from the previous response.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._get_api_list(
+            "/v1/environments?beta=true",
+            page=AsyncPageCursor[BetaEnvironment],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "include_archived": include_archived,
+                        "limit": limit,
+                        "page": page,
+                    },
+                    environment_list_params.EnvironmentListParams,
+                ),
+            ),
+            model=BetaEnvironment,
+        )
+
+    async def delete(
+        self,
+        environment_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaEnvironmentDeleteResponse:
+        """Delete an environment by ID.
+
+        Returns a confirmation of the deletion.
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not environment_id:
+            raise ValueError(f"Expected a non-empty value for `environment_id` but received {environment_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._delete(
+            path_template("/v1/environments/{environment_id}?beta=true", environment_id=environment_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaEnvironmentDeleteResponse,
+        )
+
+    async def archive(
+        self,
+        environment_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaEnvironment:
+        """Archive an environment by ID.
+
+        Archived environments cannot be used to create new
+        sessions.
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not environment_id:
+            raise ValueError(f"Expected a non-empty value for `environment_id` but received {environment_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._post(
+            path_template("/v1/environments/{environment_id}/archive?beta=true", environment_id=environment_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaEnvironment,
+        )
+
+
+class EnvironmentsWithRawResponse:
+    def __init__(self, environments: Environments) -> None:
+        self._environments = environments
+
+        self.create = _legacy_response.to_raw_response_wrapper(
+            environments.create,
+        )
+        self.retrieve = _legacy_response.to_raw_response_wrapper(
+            environments.retrieve,
+        )
+        self.update = _legacy_response.to_raw_response_wrapper(
+            environments.update,
+        )
+        self.list = _legacy_response.to_raw_response_wrapper(
+            environments.list,
+        )
+        self.delete = _legacy_response.to_raw_response_wrapper(
+            environments.delete,
+        )
+        self.archive = _legacy_response.to_raw_response_wrapper(
+            environments.archive,
+        )
+
+
+class AsyncEnvironmentsWithRawResponse:
+    def __init__(self, environments: AsyncEnvironments) -> None:
+        self._environments = environments
+
+        self.create = _legacy_response.async_to_raw_response_wrapper(
+            environments.create,
+        )
+        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
+            environments.retrieve,
+        )
+        self.update = _legacy_response.async_to_raw_response_wrapper(
+            environments.update,
+        )
+        self.list = _legacy_response.async_to_raw_response_wrapper(
+            environments.list,
+        )
+        self.delete = _legacy_response.async_to_raw_response_wrapper(
+            environments.delete,
+        )
+        self.archive = _legacy_response.async_to_raw_response_wrapper(
+            environments.archive,
+        )
+
+
+class EnvironmentsWithStreamingResponse:
+    def __init__(self, environments: Environments) -> None:
+        self._environments = environments
+
+        self.create = to_streamed_response_wrapper(
+            environments.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            environments.retrieve,
+        )
+        self.update = to_streamed_response_wrapper(
+            environments.update,
+        )
+        self.list = to_streamed_response_wrapper(
+            environments.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            environments.delete,
+        )
+        self.archive = to_streamed_response_wrapper(
+            environments.archive,
+        )
+
+
+class AsyncEnvironmentsWithStreamingResponse:
+    def __init__(self, environments: AsyncEnvironments) -> None:
+        self._environments = environments
+
+        self.create = async_to_streamed_response_wrapper(
+            environments.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            environments.retrieve,
+        )
+        self.update = async_to_streamed_response_wrapper(
+            environments.update,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            environments.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            environments.delete,
+        )
+        self.archive = async_to_streamed_response_wrapper(
+            environments.archive,
+        )

venv/lib/python3.12/site-packages/anthropic/resources/beta/files.py

@@ -0,0 +1,731 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Mapping, cast
+from itertools import chain
+
+import httpx
+
+from ... import _legacy_response
+from ..._types import Body, Omit, Query, Headers, NotGiven, FileTypes, omit, not_given
+from ..._utils import (
+    is_given,
+    extract_files,
+    path_template,
+    maybe_transform,
+    strip_not_given,
+    deepcopy_minimal,
+    async_maybe_transform,
+)
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from ..._response import (
+    BinaryAPIResponse,
+    AsyncBinaryAPIResponse,
+    StreamedBinaryAPIResponse,
+    AsyncStreamedBinaryAPIResponse,
+    to_streamed_response_wrapper,
+    to_custom_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+    to_custom_streamed_response_wrapper,
+    async_to_custom_raw_response_wrapper,
+    async_to_custom_streamed_response_wrapper,
+)
+from ...pagination import SyncPage, AsyncPage
+from ...types.beta import file_list_params, file_upload_params
+from ..._base_client import AsyncPaginator, make_request_options
+from ...lib._stainless_helpers import stainless_helper_header_from_file as _stainless_helper_header_from_file
+from ...types.beta.deleted_file import DeletedFile
+from ...types.beta.file_metadata import FileMetadata
+from ...types.anthropic_beta_param import AnthropicBetaParam
+
+__all__ = ["Files", "AsyncFiles"]
+
+
+class Files(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> FilesWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return FilesWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> FilesWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return FilesWithStreamingResponse(self)
+
+    def list(
+        self,
+        *,
+        after_id: str | Omit = omit,
+        before_id: str | Omit = omit,
+        limit: int | Omit = omit,
+        scope_id: str | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncPage[FileMetadata]:
+        """List Files
+
+        Args:
+          after_id: ID of the object to use as a cursor for pagination.
+
+        When provided, returns the
+              page of results immediately after this object.
+
+          before_id: ID of the object to use as a cursor for pagination. When provided, returns the
+              page of results immediately before this object.
+
+          limit: Number of items to return per page.
+
+              Defaults to `20`. Ranges from `1` to `1000`.
+
+          scope_id: Filter by scope ID. Only returns files associated with the specified scope
+              (e.g., a session ID).
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["files-api-2025-04-14"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "files-api-2025-04-14", **(extra_headers or {})}
+        return self._get_api_list(
+            "/v1/files?beta=true",
+            page=SyncPage[FileMetadata],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after_id": after_id,
+                        "before_id": before_id,
+                        "limit": limit,
+                        "scope_id": scope_id,
+                    },
+                    file_list_params.FileListParams,
+                ),
+            ),
+            model=FileMetadata,
+        )
+
+    def delete(
+        self,
+        file_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> DeletedFile:
+        """
+        Delete File
+
+        Args:
+          file_id: ID of the File.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not file_id:
+            raise ValueError(f"Expected a non-empty value for `file_id` but received {file_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["files-api-2025-04-14"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "files-api-2025-04-14", **(extra_headers or {})}
+        return self._delete(
+            path_template("/v1/files/{file_id}?beta=true", file_id=file_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=DeletedFile,
+        )
+
+    def download(
+        self,
+        file_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BinaryAPIResponse:
+        """
+        Download File
+
+        Args:
+          file_id: ID of the File.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not file_id:
+            raise ValueError(f"Expected a non-empty value for `file_id` but received {file_id!r}")
+        extra_headers = {"Accept": "application/binary", **(extra_headers or {})}
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["files-api-2025-04-14"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "files-api-2025-04-14", **(extra_headers or {})}
+        return self._get(
+            path_template("/v1/files/{file_id}/content?beta=true", file_id=file_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BinaryAPIResponse,
+        )
+
+    def retrieve_metadata(
+        self,
+        file_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> FileMetadata:
+        """
+        Get File Metadata
+
+        Args:
+          file_id: ID of the File.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not file_id:
+            raise ValueError(f"Expected a non-empty value for `file_id` but received {file_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["files-api-2025-04-14"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "files-api-2025-04-14", **(extra_headers or {})}
+        return self._get(
+            path_template("/v1/files/{file_id}?beta=true", file_id=file_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=FileMetadata,
+        )
+
+    def upload(
+        self,
+        *,
+        file: FileTypes,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> FileMetadata:
+        """
+        Upload File
+
+        Args:
+          file: The file to upload
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["files-api-2025-04-14"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "files-api-2025-04-14", **(extra_headers or {})}
+        extra_headers = {**_stainless_helper_header_from_file(file), **extra_headers}
+        body = deepcopy_minimal({"file": file})
+        files = extract_files(cast(Mapping[str, object], body), paths=[["file"]])
+        # It should be noted that the actual Content-Type header that will be
+        # sent to the server will contain a `boundary` parameter, e.g.
+        # multipart/form-data; boundary=---abc--
+        extra_headers["Content-Type"] = "multipart/form-data"
+        return self._post(
+            "/v1/files?beta=true",
+            body=maybe_transform(body, file_upload_params.FileUploadParams),
+            files=files,
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=FileMetadata,
+        )
+
+
+class AsyncFiles(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncFilesWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncFilesWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncFilesWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return AsyncFilesWithStreamingResponse(self)
+
+    def list(
+        self,
+        *,
+        after_id: str | Omit = omit,
+        before_id: str | Omit = omit,
+        limit: int | Omit = omit,
+        scope_id: str | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[FileMetadata, AsyncPage[FileMetadata]]:
+        """List Files
+
+        Args:
+          after_id: ID of the object to use as a cursor for pagination.
+
+        When provided, returns the
+              page of results immediately after this object.
+
+          before_id: ID of the object to use as a cursor for pagination. When provided, returns the
+              page of results immediately before this object.
+
+          limit: Number of items to return per page.
+
+              Defaults to `20`. Ranges from `1` to `1000`.
+
+          scope_id: Filter by scope ID. Only returns files associated with the specified scope
+              (e.g., a session ID).
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["files-api-2025-04-14"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "files-api-2025-04-14", **(extra_headers or {})}
+        return self._get_api_list(
+            "/v1/files?beta=true",
+            page=AsyncPage[FileMetadata],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after_id": after_id,
+                        "before_id": before_id,
+                        "limit": limit,
+                        "scope_id": scope_id,
+                    },
+                    file_list_params.FileListParams,
+                ),
+            ),
+            model=FileMetadata,
+        )
+
+    async def delete(
+        self,
+        file_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> DeletedFile:
+        """
+        Delete File
+
+        Args:
+          file_id: ID of the File.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not file_id:
+            raise ValueError(f"Expected a non-empty value for `file_id` but received {file_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["files-api-2025-04-14"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "files-api-2025-04-14", **(extra_headers or {})}
+        return await self._delete(
+            path_template("/v1/files/{file_id}?beta=true", file_id=file_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=DeletedFile,
+        )
+
+    async def download(
+        self,
+        file_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncBinaryAPIResponse:
+        """
+        Download File
+
+        Args:
+          file_id: ID of the File.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not file_id:
+            raise ValueError(f"Expected a non-empty value for `file_id` but received {file_id!r}")
+        extra_headers = {"Accept": "application/binary", **(extra_headers or {})}
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["files-api-2025-04-14"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "files-api-2025-04-14", **(extra_headers or {})}
+        return await self._get(
+            path_template("/v1/files/{file_id}/content?beta=true", file_id=file_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=AsyncBinaryAPIResponse,
+        )
+
+    async def retrieve_metadata(
+        self,
+        file_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> FileMetadata:
+        """
+        Get File Metadata
+
+        Args:
+          file_id: ID of the File.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not file_id:
+            raise ValueError(f"Expected a non-empty value for `file_id` but received {file_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["files-api-2025-04-14"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "files-api-2025-04-14", **(extra_headers or {})}
+        return await self._get(
+            path_template("/v1/files/{file_id}?beta=true", file_id=file_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=FileMetadata,
+        )
+
+    async def upload(
+        self,
+        *,
+        file: FileTypes,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> FileMetadata:
+        """
+        Upload File
+
+        Args:
+          file: The file to upload
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["files-api-2025-04-14"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "files-api-2025-04-14", **(extra_headers or {})}
+        extra_headers = {**_stainless_helper_header_from_file(file), **extra_headers}
+        body = deepcopy_minimal({"file": file})
+        files = extract_files(cast(Mapping[str, object], body), paths=[["file"]])
+        # It should be noted that the actual Content-Type header that will be
+        # sent to the server will contain a `boundary` parameter, e.g.
+        # multipart/form-data; boundary=---abc--
+        extra_headers["Content-Type"] = "multipart/form-data"
+        return await self._post(
+            "/v1/files?beta=true",
+            body=await async_maybe_transform(body, file_upload_params.FileUploadParams),
+            files=files,
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=FileMetadata,
+        )
+
+
+class FilesWithRawResponse:
+    def __init__(self, files: Files) -> None:
+        self._files = files
+
+        self.list = _legacy_response.to_raw_response_wrapper(
+            files.list,
+        )
+        self.delete = _legacy_response.to_raw_response_wrapper(
+            files.delete,
+        )
+        self.download = to_custom_raw_response_wrapper(
+            files.download,
+            BinaryAPIResponse,
+        )
+        self.retrieve_metadata = _legacy_response.to_raw_response_wrapper(
+            files.retrieve_metadata,
+        )
+        self.upload = _legacy_response.to_raw_response_wrapper(
+            files.upload,
+        )
+
+
+class AsyncFilesWithRawResponse:
+    def __init__(self, files: AsyncFiles) -> None:
+        self._files = files
+
+        self.list = _legacy_response.async_to_raw_response_wrapper(
+            files.list,
+        )
+        self.delete = _legacy_response.async_to_raw_response_wrapper(
+            files.delete,
+        )
+        self.download = async_to_custom_raw_response_wrapper(
+            files.download,
+            AsyncBinaryAPIResponse,
+        )
+        self.retrieve_metadata = _legacy_response.async_to_raw_response_wrapper(
+            files.retrieve_metadata,
+        )
+        self.upload = _legacy_response.async_to_raw_response_wrapper(
+            files.upload,
+        )
+
+
+class FilesWithStreamingResponse:
+    def __init__(self, files: Files) -> None:
+        self._files = files
+
+        self.list = to_streamed_response_wrapper(
+            files.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            files.delete,
+        )
+        self.download = to_custom_streamed_response_wrapper(
+            files.download,
+            StreamedBinaryAPIResponse,
+        )
+        self.retrieve_metadata = to_streamed_response_wrapper(
+            files.retrieve_metadata,
+        )
+        self.upload = to_streamed_response_wrapper(
+            files.upload,
+        )
+
+
+class AsyncFilesWithStreamingResponse:
+    def __init__(self, files: AsyncFiles) -> None:
+        self._files = files
+
+        self.list = async_to_streamed_response_wrapper(
+            files.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            files.delete,
+        )
+        self.download = async_to_custom_streamed_response_wrapper(
+            files.download,
+            AsyncStreamedBinaryAPIResponse,
+        )
+        self.retrieve_metadata = async_to_streamed_response_wrapper(
+            files.retrieve_metadata,
+        )
+        self.upload = async_to_streamed_response_wrapper(
+            files.upload,
+        )

venv/lib/python3.12/site-packages/anthropic/resources/beta/messages/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .batches import (
+    Batches,
+    AsyncBatches,
+    BatchesWithRawResponse,
+    AsyncBatchesWithRawResponse,
+    BatchesWithStreamingResponse,
+    AsyncBatchesWithStreamingResponse,
+)
+from .messages import (
+    Messages,
+    AsyncMessages,
+    MessagesWithRawResponse,
+    AsyncMessagesWithRawResponse,
+    MessagesWithStreamingResponse,
+    AsyncMessagesWithStreamingResponse,
+)
+
+__all__ = [
+    "Batches",
+    "AsyncBatches",
+    "BatchesWithRawResponse",
+    "AsyncBatchesWithRawResponse",
+    "BatchesWithStreamingResponse",
+    "AsyncBatchesWithStreamingResponse",
+    "Messages",
+    "AsyncMessages",
+    "MessagesWithRawResponse",
+    "AsyncMessagesWithRawResponse",
+    "MessagesWithStreamingResponse",
+    "AsyncMessagesWithStreamingResponse",
+]

venv/lib/python3.12/site-packages/anthropic/resources/beta/messages/batches.py

@@ -0,0 +1,900 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Iterable
+from itertools import chain
+
+import httpx
+
+from .... import _legacy_response
+from ...._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ...._utils import is_given, path_template, maybe_transform, strip_not_given, async_maybe_transform
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ....pagination import SyncPage, AsyncPage
+from ...._exceptions import AnthropicError
+from ...._base_client import AsyncPaginator, make_request_options
+from ...._decoders.jsonl import JSONLDecoder, AsyncJSONLDecoder
+from ....types.beta.messages import batch_list_params, batch_create_params
+from ....types.anthropic_beta_param import AnthropicBetaParam
+from ....types.beta.messages.beta_message_batch import BetaMessageBatch
+from ....types.beta.messages.beta_deleted_message_batch import BetaDeletedMessageBatch
+from ....types.beta.messages.beta_message_batch_individual_response import BetaMessageBatchIndividualResponse
+
+__all__ = ["Batches", "AsyncBatches"]
+
+
+class Batches(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> BatchesWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return BatchesWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> BatchesWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return BatchesWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        requests: Iterable[batch_create_params.Request],
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaMessageBatch:
+        """
+        Send a batch of Message creation requests.
+
+        The Message Batches API can be used to process multiple Messages API requests at
+        once. Once a Message Batch is created, it begins processing immediately. Batches
+        can take up to 24 hours to complete.
+
+        Learn more about the Message Batches API in our
+        [user guide](https://docs.claude.com/en/docs/build-with-claude/batch-processing)
+
+        Args:
+          requests: List of requests for prompt completion. Each is an individual request to create
+              a Message.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["message-batches-2024-09-24"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "message-batches-2024-09-24", **(extra_headers or {})}
+        return self._post(
+            "/v1/messages/batches?beta=true",
+            body=maybe_transform({"requests": requests}, batch_create_params.BatchCreateParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaMessageBatch,
+        )
+
+    def retrieve(
+        self,
+        message_batch_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaMessageBatch:
+        """This endpoint is idempotent and can be used to poll for Message Batch
+        completion.
+
+        To access the results of a Message Batch, make a request to the
+        `results_url` field in the response.
+
+        Learn more about the Message Batches API in our
+        [user guide](https://docs.claude.com/en/docs/build-with-claude/batch-processing)
+
+        Args:
+          message_batch_id: ID of the Message Batch.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not message_batch_id:
+            raise ValueError(f"Expected a non-empty value for `message_batch_id` but received {message_batch_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["message-batches-2024-09-24"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "message-batches-2024-09-24", **(extra_headers or {})}
+        return self._get(
+            path_template("/v1/messages/batches/{message_batch_id}?beta=true", message_batch_id=message_batch_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaMessageBatch,
+        )
+
+    def list(
+        self,
+        *,
+        after_id: str | Omit = omit,
+        before_id: str | Omit = omit,
+        limit: int | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncPage[BetaMessageBatch]:
+        """List all Message Batches within a Workspace.
+
+        Most recently created batches are
+        returned first.
+
+        Learn more about the Message Batches API in our
+        [user guide](https://docs.claude.com/en/docs/build-with-claude/batch-processing)
+
+        Args:
+          after_id: ID of the object to use as a cursor for pagination. When provided, returns the
+              page of results immediately after this object.
+
+          before_id: ID of the object to use as a cursor for pagination. When provided, returns the
+              page of results immediately before this object.
+
+          limit: Number of items to return per page.
+
+              Defaults to `20`. Ranges from `1` to `1000`.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["message-batches-2024-09-24"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "message-batches-2024-09-24", **(extra_headers or {})}
+        return self._get_api_list(
+            "/v1/messages/batches?beta=true",
+            page=SyncPage[BetaMessageBatch],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after_id": after_id,
+                        "before_id": before_id,
+                        "limit": limit,
+                    },
+                    batch_list_params.BatchListParams,
+                ),
+            ),
+            model=BetaMessageBatch,
+        )
+
+    def delete(
+        self,
+        message_batch_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaDeletedMessageBatch:
+        """
+        Delete a Message Batch.
+
+        Message Batches can only be deleted once they've finished processing. If you'd
+        like to delete an in-progress batch, you must first cancel it.
+
+        Learn more about the Message Batches API in our
+        [user guide](https://docs.claude.com/en/docs/build-with-claude/batch-processing)
+
+        Args:
+          message_batch_id: ID of the Message Batch.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not message_batch_id:
+            raise ValueError(f"Expected a non-empty value for `message_batch_id` but received {message_batch_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["message-batches-2024-09-24"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "message-batches-2024-09-24", **(extra_headers or {})}
+        return self._delete(
+            path_template("/v1/messages/batches/{message_batch_id}?beta=true", message_batch_id=message_batch_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaDeletedMessageBatch,
+        )
+
+    def cancel(
+        self,
+        message_batch_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaMessageBatch:
+        """Batches may be canceled any time before processing ends.
+
+        Once cancellation is
+        initiated, the batch enters a `canceling` state, at which time the system may
+        complete any in-progress, non-interruptible requests before finalizing
+        cancellation.
+
+        The number of canceled requests is specified in `request_counts`. To determine
+        which requests were canceled, check the individual results within the batch.
+        Note that cancellation may not result in any canceled requests if they were
+        non-interruptible.
+
+        Learn more about the Message Batches API in our
+        [user guide](https://docs.claude.com/en/docs/build-with-claude/batch-processing)
+
+        Args:
+          message_batch_id: ID of the Message Batch.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not message_batch_id:
+            raise ValueError(f"Expected a non-empty value for `message_batch_id` but received {message_batch_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["message-batches-2024-09-24"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "message-batches-2024-09-24", **(extra_headers or {})}
+        return self._post(
+            path_template(
+                "/v1/messages/batches/{message_batch_id}/cancel?beta=true", message_batch_id=message_batch_id
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaMessageBatch,
+        )
+
+    def results(
+        self,
+        message_batch_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> JSONLDecoder[BetaMessageBatchIndividualResponse]:
+        """
+        Streams the results of a Message Batch as a `.jsonl` file.
+
+        Each line in the file is a JSON object containing the result of a single request
+        in the Message Batch. Results are not guaranteed to be in the same order as
+        requests. Use the `custom_id` field to match results to requests.
+
+        Learn more about the Message Batches API in our
+        [user guide](https://docs.claude.com/en/docs/build-with-claude/batch-processing)
+
+        Args:
+          message_batch_id: ID of the Message Batch.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not message_batch_id:
+            raise ValueError(f"Expected a non-empty value for `message_batch_id` but received {message_batch_id!r}")
+
+        batch = self.retrieve(message_batch_id=message_batch_id)
+        if not batch.results_url:
+            raise AnthropicError(
+                f"No `results_url` for the given batch; Has it finished processing? {batch.processing_status}"
+            )
+
+        extra_headers = {"Accept": "application/binary", **(extra_headers or {})}
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["message-batches-2024-09-24"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "message-batches-2024-09-24", **(extra_headers or {})}
+        return self._get(
+            path_template(batch.results_url, message_batch_id=message_batch_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=JSONLDecoder[BetaMessageBatchIndividualResponse],
+            stream=True,
+        )
+
+
+class AsyncBatches(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncBatchesWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncBatchesWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncBatchesWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return AsyncBatchesWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        requests: Iterable[batch_create_params.Request],
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaMessageBatch:
+        """
+        Send a batch of Message creation requests.
+
+        The Message Batches API can be used to process multiple Messages API requests at
+        once. Once a Message Batch is created, it begins processing immediately. Batches
+        can take up to 24 hours to complete.
+
+        Learn more about the Message Batches API in our
+        [user guide](https://docs.claude.com/en/docs/build-with-claude/batch-processing)
+
+        Args:
+          requests: List of requests for prompt completion. Each is an individual request to create
+              a Message.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["message-batches-2024-09-24"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "message-batches-2024-09-24", **(extra_headers or {})}
+        return await self._post(
+            "/v1/messages/batches?beta=true",
+            body=await async_maybe_transform({"requests": requests}, batch_create_params.BatchCreateParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaMessageBatch,
+        )
+
+    async def retrieve(
+        self,
+        message_batch_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaMessageBatch:
+        """This endpoint is idempotent and can be used to poll for Message Batch
+        completion.
+
+        To access the results of a Message Batch, make a request to the
+        `results_url` field in the response.
+
+        Learn more about the Message Batches API in our
+        [user guide](https://docs.claude.com/en/docs/build-with-claude/batch-processing)
+
+        Args:
+          message_batch_id: ID of the Message Batch.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not message_batch_id:
+            raise ValueError(f"Expected a non-empty value for `message_batch_id` but received {message_batch_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["message-batches-2024-09-24"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "message-batches-2024-09-24", **(extra_headers or {})}
+        return await self._get(
+            path_template("/v1/messages/batches/{message_batch_id}?beta=true", message_batch_id=message_batch_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaMessageBatch,
+        )
+
+    def list(
+        self,
+        *,
+        after_id: str | Omit = omit,
+        before_id: str | Omit = omit,
+        limit: int | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[BetaMessageBatch, AsyncPage[BetaMessageBatch]]:
+        """List all Message Batches within a Workspace.
+
+        Most recently created batches are
+        returned first.
+
+        Learn more about the Message Batches API in our
+        [user guide](https://docs.claude.com/en/docs/build-with-claude/batch-processing)
+
+        Args:
+          after_id: ID of the object to use as a cursor for pagination. When provided, returns the
+              page of results immediately after this object.
+
+          before_id: ID of the object to use as a cursor for pagination. When provided, returns the
+              page of results immediately before this object.
+
+          limit: Number of items to return per page.
+
+              Defaults to `20`. Ranges from `1` to `1000`.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["message-batches-2024-09-24"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "message-batches-2024-09-24", **(extra_headers or {})}
+        return self._get_api_list(
+            "/v1/messages/batches?beta=true",
+            page=AsyncPage[BetaMessageBatch],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after_id": after_id,
+                        "before_id": before_id,
+                        "limit": limit,
+                    },
+                    batch_list_params.BatchListParams,
+                ),
+            ),
+            model=BetaMessageBatch,
+        )
+
+    async def delete(
+        self,
+        message_batch_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaDeletedMessageBatch:
+        """
+        Delete a Message Batch.
+
+        Message Batches can only be deleted once they've finished processing. If you'd
+        like to delete an in-progress batch, you must first cancel it.
+
+        Learn more about the Message Batches API in our
+        [user guide](https://docs.claude.com/en/docs/build-with-claude/batch-processing)
+
+        Args:
+          message_batch_id: ID of the Message Batch.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not message_batch_id:
+            raise ValueError(f"Expected a non-empty value for `message_batch_id` but received {message_batch_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["message-batches-2024-09-24"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "message-batches-2024-09-24", **(extra_headers or {})}
+        return await self._delete(
+            path_template("/v1/messages/batches/{message_batch_id}?beta=true", message_batch_id=message_batch_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaDeletedMessageBatch,
+        )
+
+    async def cancel(
+        self,
+        message_batch_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaMessageBatch:
+        """Batches may be canceled any time before processing ends.
+
+        Once cancellation is
+        initiated, the batch enters a `canceling` state, at which time the system may
+        complete any in-progress, non-interruptible requests before finalizing
+        cancellation.
+
+        The number of canceled requests is specified in `request_counts`. To determine
+        which requests were canceled, check the individual results within the batch.
+        Note that cancellation may not result in any canceled requests if they were
+        non-interruptible.
+
+        Learn more about the Message Batches API in our
+        [user guide](https://docs.claude.com/en/docs/build-with-claude/batch-processing)
+
+        Args:
+          message_batch_id: ID of the Message Batch.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not message_batch_id:
+            raise ValueError(f"Expected a non-empty value for `message_batch_id` but received {message_batch_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["message-batches-2024-09-24"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "message-batches-2024-09-24", **(extra_headers or {})}
+        return await self._post(
+            path_template(
+                "/v1/messages/batches/{message_batch_id}/cancel?beta=true", message_batch_id=message_batch_id
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaMessageBatch,
+        )
+
+    async def results(
+        self,
+        message_batch_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncJSONLDecoder[BetaMessageBatchIndividualResponse]:
+        """
+        Streams the results of a Message Batch as a `.jsonl` file.
+
+        Each line in the file is a JSON object containing the result of a single request
+        in the Message Batch. Results are not guaranteed to be in the same order as
+        requests. Use the `custom_id` field to match results to requests.
+
+        Learn more about the Message Batches API in our
+        [user guide](https://docs.claude.com/en/docs/build-with-claude/batch-processing)
+
+        Args:
+          message_batch_id: ID of the Message Batch.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not message_batch_id:
+            raise ValueError(f"Expected a non-empty value for `message_batch_id` but received {message_batch_id!r}")
+
+        batch = await self.retrieve(message_batch_id=message_batch_id)
+        if not batch.results_url:
+            raise AnthropicError(
+                f"No `results_url` for the given batch; Has it finished processing? {batch.processing_status}"
+            )
+
+        extra_headers = {"Accept": "application/binary", **(extra_headers or {})}
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["message-batches-2024-09-24"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "message-batches-2024-09-24", **(extra_headers or {})}
+        return await self._get(
+            path_template(batch.results_url, message_batch_id=message_batch_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=AsyncJSONLDecoder[BetaMessageBatchIndividualResponse],
+            stream=True,
+        )
+
+
+class BatchesWithRawResponse:
+    def __init__(self, batches: Batches) -> None:
+        self._batches = batches
+
+        self.create = _legacy_response.to_raw_response_wrapper(
+            batches.create,
+        )
+        self.retrieve = _legacy_response.to_raw_response_wrapper(
+            batches.retrieve,
+        )
+        self.list = _legacy_response.to_raw_response_wrapper(
+            batches.list,
+        )
+        self.delete = _legacy_response.to_raw_response_wrapper(
+            batches.delete,
+        )
+        self.cancel = _legacy_response.to_raw_response_wrapper(
+            batches.cancel,
+        )
+        self.results = _legacy_response.to_raw_response_wrapper(
+            batches.results,
+        )
+
+
+class AsyncBatchesWithRawResponse:
+    def __init__(self, batches: AsyncBatches) -> None:
+        self._batches = batches
+
+        self.create = _legacy_response.async_to_raw_response_wrapper(
+            batches.create,
+        )
+        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
+            batches.retrieve,
+        )
+        self.list = _legacy_response.async_to_raw_response_wrapper(
+            batches.list,
+        )
+        self.delete = _legacy_response.async_to_raw_response_wrapper(
+            batches.delete,
+        )
+        self.cancel = _legacy_response.async_to_raw_response_wrapper(
+            batches.cancel,
+        )
+        self.results = _legacy_response.async_to_raw_response_wrapper(
+            batches.results,
+        )
+
+
+class BatchesWithStreamingResponse:
+    def __init__(self, batches: Batches) -> None:
+        self._batches = batches
+
+        self.create = to_streamed_response_wrapper(
+            batches.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            batches.retrieve,
+        )
+        self.list = to_streamed_response_wrapper(
+            batches.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            batches.delete,
+        )
+        self.cancel = to_streamed_response_wrapper(
+            batches.cancel,
+        )
+        self.results = to_streamed_response_wrapper(
+            batches.results,
+        )
+
+
+class AsyncBatchesWithStreamingResponse:
+    def __init__(self, batches: AsyncBatches) -> None:
+        self._batches = batches
+
+        self.create = async_to_streamed_response_wrapper(
+            batches.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            batches.retrieve,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            batches.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            batches.delete,
+        )
+        self.cancel = async_to_streamed_response_wrapper(
+            batches.cancel,
+        )
+        self.results = async_to_streamed_response_wrapper(
+            batches.results,
+        )

venv/lib/python3.12/site-packages/anthropic/resources/beta/models.py

@@ -0,0 +1,331 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+
+import httpx
+
+from ... import _legacy_response
+from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ..._utils import is_given, path_template, maybe_transform, strip_not_given
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from ..._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ...pagination import SyncPage, AsyncPage
+from ...types.beta import model_list_params
+from ..._base_client import AsyncPaginator, make_request_options
+from ...types.anthropic_beta_param import AnthropicBetaParam
+from ...types.beta.beta_model_info import BetaModelInfo
+
+__all__ = ["Models", "AsyncModels"]
+
+
+class Models(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> ModelsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return ModelsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ModelsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return ModelsWithStreamingResponse(self)
+
+    def retrieve(
+        self,
+        model_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaModelInfo:
+        """
+        Get a specific model.
+
+        The Models API response can be used to determine information about a specific
+        model or resolve a model alias to a model ID.
+
+        Args:
+          model_id: Model identifier or alias.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not model_id:
+            raise ValueError(f"Expected a non-empty value for `model_id` but received {model_id!r}")
+        extra_headers = {
+            **strip_not_given({"anthropic-beta": ",".join(str(e) for e in betas) if is_given(betas) else not_given}),
+            **(extra_headers or {}),
+        }
+        return self._get(
+            path_template("/v1/models/{model_id}?beta=true", model_id=model_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaModelInfo,
+        )
+
+    def list(
+        self,
+        *,
+        after_id: str | Omit = omit,
+        before_id: str | Omit = omit,
+        limit: int | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncPage[BetaModelInfo]:
+        """
+        List available models.
+
+        The Models API response can be used to determine which models are available for
+        use in the API. More recently released models are listed first.
+
+        Args:
+          after_id: ID of the object to use as a cursor for pagination. When provided, returns the
+              page of results immediately after this object.
+
+          before_id: ID of the object to use as a cursor for pagination. When provided, returns the
+              page of results immediately before this object.
+
+          limit: Number of items to return per page.
+
+              Defaults to `20`. Ranges from `1` to `1000`.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given({"anthropic-beta": ",".join(str(e) for e in betas) if is_given(betas) else not_given}),
+            **(extra_headers or {}),
+        }
+        return self._get_api_list(
+            "/v1/models?beta=true",
+            page=SyncPage[BetaModelInfo],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after_id": after_id,
+                        "before_id": before_id,
+                        "limit": limit,
+                    },
+                    model_list_params.ModelListParams,
+                ),
+            ),
+            model=BetaModelInfo,
+        )
+
+
+class AsyncModels(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncModelsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncModelsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncModelsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return AsyncModelsWithStreamingResponse(self)
+
+    async def retrieve(
+        self,
+        model_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaModelInfo:
+        """
+        Get a specific model.
+
+        The Models API response can be used to determine information about a specific
+        model or resolve a model alias to a model ID.
+
+        Args:
+          model_id: Model identifier or alias.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not model_id:
+            raise ValueError(f"Expected a non-empty value for `model_id` but received {model_id!r}")
+        extra_headers = {
+            **strip_not_given({"anthropic-beta": ",".join(str(e) for e in betas) if is_given(betas) else not_given}),
+            **(extra_headers or {}),
+        }
+        return await self._get(
+            path_template("/v1/models/{model_id}?beta=true", model_id=model_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaModelInfo,
+        )
+
+    def list(
+        self,
+        *,
+        after_id: str | Omit = omit,
+        before_id: str | Omit = omit,
+        limit: int | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[BetaModelInfo, AsyncPage[BetaModelInfo]]:
+        """
+        List available models.
+
+        The Models API response can be used to determine which models are available for
+        use in the API. More recently released models are listed first.
+
+        Args:
+          after_id: ID of the object to use as a cursor for pagination. When provided, returns the
+              page of results immediately after this object.
+
+          before_id: ID of the object to use as a cursor for pagination. When provided, returns the
+              page of results immediately before this object.
+
+          limit: Number of items to return per page.
+
+              Defaults to `20`. Ranges from `1` to `1000`.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given({"anthropic-beta": ",".join(str(e) for e in betas) if is_given(betas) else not_given}),
+            **(extra_headers or {}),
+        }
+        return self._get_api_list(
+            "/v1/models?beta=true",
+            page=AsyncPage[BetaModelInfo],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after_id": after_id,
+                        "before_id": before_id,
+                        "limit": limit,
+                    },
+                    model_list_params.ModelListParams,
+                ),
+            ),
+            model=BetaModelInfo,
+        )
+
+
+class ModelsWithRawResponse:
+    def __init__(self, models: Models) -> None:
+        self._models = models
+
+        self.retrieve = _legacy_response.to_raw_response_wrapper(
+            models.retrieve,
+        )
+        self.list = _legacy_response.to_raw_response_wrapper(
+            models.list,
+        )
+
+
+class AsyncModelsWithRawResponse:
+    def __init__(self, models: AsyncModels) -> None:
+        self._models = models
+
+        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
+            models.retrieve,
+        )
+        self.list = _legacy_response.async_to_raw_response_wrapper(
+            models.list,
+        )
+
+
+class ModelsWithStreamingResponse:
+    def __init__(self, models: Models) -> None:
+        self._models = models
+
+        self.retrieve = to_streamed_response_wrapper(
+            models.retrieve,
+        )
+        self.list = to_streamed_response_wrapper(
+            models.list,
+        )
+
+
+class AsyncModelsWithStreamingResponse:
+    def __init__(self, models: AsyncModels) -> None:
+        self._models = models
+
+        self.retrieve = async_to_streamed_response_wrapper(
+            models.retrieve,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            models.list,
+        )

venv/lib/python3.12/site-packages/anthropic/resources/beta/sessions/__init__.py

@@ -0,0 +1,47 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .events import (
+    Events,
+    AsyncEvents,
+    EventsWithRawResponse,
+    AsyncEventsWithRawResponse,
+    EventsWithStreamingResponse,
+    AsyncEventsWithStreamingResponse,
+)
+from .sessions import (
+    Sessions,
+    AsyncSessions,
+    SessionsWithRawResponse,
+    AsyncSessionsWithRawResponse,
+    SessionsWithStreamingResponse,
+    AsyncSessionsWithStreamingResponse,
+)
+from .resources import (
+    Resources,
+    AsyncResources,
+    ResourcesWithRawResponse,
+    AsyncResourcesWithRawResponse,
+    ResourcesWithStreamingResponse,
+    AsyncResourcesWithStreamingResponse,
+)
+
+__all__ = [
+    "Events",
+    "AsyncEvents",
+    "EventsWithRawResponse",
+    "AsyncEventsWithRawResponse",
+    "EventsWithStreamingResponse",
+    "AsyncEventsWithStreamingResponse",
+    "Resources",
+    "AsyncResources",
+    "ResourcesWithRawResponse",
+    "AsyncResourcesWithRawResponse",
+    "ResourcesWithStreamingResponse",
+    "AsyncResourcesWithStreamingResponse",
+    "Sessions",
+    "AsyncSessions",
+    "SessionsWithRawResponse",
+    "AsyncSessionsWithRawResponse",
+    "SessionsWithStreamingResponse",
+    "AsyncSessionsWithStreamingResponse",
+]

venv/lib/python3.12/site-packages/anthropic/resources/beta/sessions/events.py

@@ -0,0 +1,475 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Any, List, Iterable, cast
+from itertools import chain
+from typing_extensions import Literal
+
+import httpx
+
+from .... import _legacy_response
+from ...._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ...._utils import is_given, path_template, maybe_transform, strip_not_given, async_maybe_transform
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ...._streaming import Stream, AsyncStream
+from ....pagination import SyncPageCursor, AsyncPageCursor
+from ...._base_client import AsyncPaginator, make_request_options
+from ....types.beta.sessions import event_list_params, event_send_params
+from ....types.anthropic_beta_param import AnthropicBetaParam
+from ....types.beta.sessions.beta_managed_agents_event_params import BetaManagedAgentsEventParams
+from ....types.beta.sessions.beta_managed_agents_session_event import BetaManagedAgentsSessionEvent
+from ....types.beta.sessions.beta_managed_agents_send_session_events import BetaManagedAgentsSendSessionEvents
+from ....types.beta.sessions.beta_managed_agents_stream_session_events import BetaManagedAgentsStreamSessionEvents
+
+__all__ = ["Events", "AsyncEvents"]
+
+
+class Events(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> EventsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return EventsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> EventsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return EventsWithStreamingResponse(self)
+
+    def list(
+        self,
+        session_id: str,
+        *,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        page: str | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncPageCursor[BetaManagedAgentsSessionEvent]:
+        """
+        List Events
+
+        Args:
+          limit: Query parameter for limit
+
+          order: Sort direction for results, ordered by created_at. Defaults to asc
+              (chronological).
+
+          page: Opaque pagination cursor from a previous response's next_page.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._get_api_list(
+            path_template("/v1/sessions/{session_id}/events?beta=true", session_id=session_id),
+            page=SyncPageCursor[BetaManagedAgentsSessionEvent],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "limit": limit,
+                        "order": order,
+                        "page": page,
+                    },
+                    event_list_params.EventListParams,
+                ),
+            ),
+            model=cast(
+                Any, BetaManagedAgentsSessionEvent
+            ),  # Union types cannot be passed in as arguments in the type system
+        )
+
+    def send(
+        self,
+        session_id: str,
+        *,
+        events: Iterable[BetaManagedAgentsEventParams],
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsSendSessionEvents:
+        """
+        Send Events
+
+        Args:
+          events: Events to send to the `session`.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._post(
+            path_template("/v1/sessions/{session_id}/events?beta=true", session_id=session_id),
+            body=maybe_transform({"events": events}, event_send_params.EventSendParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsSendSessionEvents,
+        )
+
+    def stream(
+        self,
+        session_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Stream[BetaManagedAgentsStreamSessionEvents]:
+        """
+        Stream Events
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._get(
+            path_template("/v1/sessions/{session_id}/events/stream?beta=true", session_id=session_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=cast(
+                Any, BetaManagedAgentsStreamSessionEvents
+            ),  # Union types cannot be passed in as arguments in the type system
+            stream=True,
+            stream_cls=Stream[BetaManagedAgentsStreamSessionEvents],
+        )
+
+
+class AsyncEvents(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncEventsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncEventsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncEventsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return AsyncEventsWithStreamingResponse(self)
+
+    def list(
+        self,
+        session_id: str,
+        *,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        page: str | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[BetaManagedAgentsSessionEvent, AsyncPageCursor[BetaManagedAgentsSessionEvent]]:
+        """
+        List Events
+
+        Args:
+          limit: Query parameter for limit
+
+          order: Sort direction for results, ordered by created_at. Defaults to asc
+              (chronological).
+
+          page: Opaque pagination cursor from a previous response's next_page.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._get_api_list(
+            path_template("/v1/sessions/{session_id}/events?beta=true", session_id=session_id),
+            page=AsyncPageCursor[BetaManagedAgentsSessionEvent],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "limit": limit,
+                        "order": order,
+                        "page": page,
+                    },
+                    event_list_params.EventListParams,
+                ),
+            ),
+            model=cast(
+                Any, BetaManagedAgentsSessionEvent
+            ),  # Union types cannot be passed in as arguments in the type system
+        )
+
+    async def send(
+        self,
+        session_id: str,
+        *,
+        events: Iterable[BetaManagedAgentsEventParams],
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsSendSessionEvents:
+        """
+        Send Events
+
+        Args:
+          events: Events to send to the `session`.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._post(
+            path_template("/v1/sessions/{session_id}/events?beta=true", session_id=session_id),
+            body=await async_maybe_transform({"events": events}, event_send_params.EventSendParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsSendSessionEvents,
+        )
+
+    async def stream(
+        self,
+        session_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncStream[BetaManagedAgentsStreamSessionEvents]:
+        """
+        Stream Events
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._get(
+            path_template("/v1/sessions/{session_id}/events/stream?beta=true", session_id=session_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=cast(
+                Any, BetaManagedAgentsStreamSessionEvents
+            ),  # Union types cannot be passed in as arguments in the type system
+            stream=True,
+            stream_cls=AsyncStream[BetaManagedAgentsStreamSessionEvents],
+        )
+
+
+class EventsWithRawResponse:
+    def __init__(self, events: Events) -> None:
+        self._events = events
+
+        self.list = _legacy_response.to_raw_response_wrapper(
+            events.list,
+        )
+        self.send = _legacy_response.to_raw_response_wrapper(
+            events.send,
+        )
+        self.stream = _legacy_response.to_raw_response_wrapper(
+            events.stream,
+        )
+
+
+class AsyncEventsWithRawResponse:
+    def __init__(self, events: AsyncEvents) -> None:
+        self._events = events
+
+        self.list = _legacy_response.async_to_raw_response_wrapper(
+            events.list,
+        )
+        self.send = _legacy_response.async_to_raw_response_wrapper(
+            events.send,
+        )
+        self.stream = _legacy_response.async_to_raw_response_wrapper(
+            events.stream,
+        )
+
+
+class EventsWithStreamingResponse:
+    def __init__(self, events: Events) -> None:
+        self._events = events
+
+        self.list = to_streamed_response_wrapper(
+            events.list,
+        )
+        self.send = to_streamed_response_wrapper(
+            events.send,
+        )
+        self.stream = to_streamed_response_wrapper(
+            events.stream,
+        )
+
+
+class AsyncEventsWithStreamingResponse:
+    def __init__(self, events: AsyncEvents) -> None:
+        self._events = events
+
+        self.list = async_to_streamed_response_wrapper(
+            events.list,
+        )
+        self.send = async_to_streamed_response_wrapper(
+            events.send,
+        )
+        self.stream = async_to_streamed_response_wrapper(
+            events.stream,
+        )

venv/lib/python3.12/site-packages/anthropic/resources/beta/sessions/resources.py

@@ -0,0 +1,769 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Any, List, Optional, cast
+from itertools import chain
+from typing_extensions import Literal
+
+import httpx
+
+from .... import _legacy_response
+from ...._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ...._utils import is_given, path_template, maybe_transform, strip_not_given, async_maybe_transform
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ....pagination import SyncPageCursor, AsyncPageCursor
+from ...._base_client import AsyncPaginator, make_request_options
+from ....types.beta.sessions import resource_add_params, resource_list_params, resource_update_params
+from ....types.anthropic_beta_param import AnthropicBetaParam
+from ....types.beta.sessions.resource_update_response import ResourceUpdateResponse
+from ....types.beta.sessions.resource_retrieve_response import ResourceRetrieveResponse
+from ....types.beta.sessions.beta_managed_agents_file_resource import BetaManagedAgentsFileResource
+from ....types.beta.sessions.beta_managed_agents_session_resource import BetaManagedAgentsSessionResource
+from ....types.beta.sessions.beta_managed_agents_delete_session_resource import BetaManagedAgentsDeleteSessionResource
+
+__all__ = ["Resources", "AsyncResources"]
+
+
+class Resources(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> ResourcesWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return ResourcesWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ResourcesWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return ResourcesWithStreamingResponse(self)
+
+    def retrieve(
+        self,
+        resource_id: str,
+        *,
+        session_id: str,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ResourceRetrieveResponse:
+        """
+        Get Session Resource
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        if not resource_id:
+            raise ValueError(f"Expected a non-empty value for `resource_id` but received {resource_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return cast(
+            ResourceRetrieveResponse,
+            self._get(
+                path_template(
+                    "/v1/sessions/{session_id}/resources/{resource_id}?beta=true",
+                    session_id=session_id,
+                    resource_id=resource_id,
+                ),
+                options=make_request_options(
+                    extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                ),
+                cast_to=cast(
+                    Any, ResourceRetrieveResponse
+                ),  # Union types cannot be passed in as arguments in the type system
+            ),
+        )
+
+    def update(
+        self,
+        resource_id: str,
+        *,
+        session_id: str,
+        authorization_token: str,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ResourceUpdateResponse:
+        """
+        Update Session Resource
+
+        Args:
+          authorization_token: New authorization token for the resource. Currently only `github_repository`
+              resources support token rotation.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        if not resource_id:
+            raise ValueError(f"Expected a non-empty value for `resource_id` but received {resource_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return cast(
+            ResourceUpdateResponse,
+            self._post(
+                path_template(
+                    "/v1/sessions/{session_id}/resources/{resource_id}?beta=true",
+                    session_id=session_id,
+                    resource_id=resource_id,
+                ),
+                body=maybe_transform(
+                    {"authorization_token": authorization_token}, resource_update_params.ResourceUpdateParams
+                ),
+                options=make_request_options(
+                    extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                ),
+                cast_to=cast(
+                    Any, ResourceUpdateResponse
+                ),  # Union types cannot be passed in as arguments in the type system
+            ),
+        )
+
+    def list(
+        self,
+        session_id: str,
+        *,
+        limit: int | Omit = omit,
+        page: str | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncPageCursor[BetaManagedAgentsSessionResource]:
+        """
+        List Session Resources
+
+        Args:
+          limit: Maximum number of resources to return per page (max 1000). If omitted, returns
+              all resources.
+
+          page: Opaque cursor from a previous response's next_page field.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._get_api_list(
+            path_template("/v1/sessions/{session_id}/resources?beta=true", session_id=session_id),
+            page=SyncPageCursor[BetaManagedAgentsSessionResource],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "limit": limit,
+                        "page": page,
+                    },
+                    resource_list_params.ResourceListParams,
+                ),
+            ),
+            model=cast(
+                Any, BetaManagedAgentsSessionResource
+            ),  # Union types cannot be passed in as arguments in the type system
+        )
+
+    def delete(
+        self,
+        resource_id: str,
+        *,
+        session_id: str,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsDeleteSessionResource:
+        """
+        Delete Session Resource
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        if not resource_id:
+            raise ValueError(f"Expected a non-empty value for `resource_id` but received {resource_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._delete(
+            path_template(
+                "/v1/sessions/{session_id}/resources/{resource_id}?beta=true",
+                session_id=session_id,
+                resource_id=resource_id,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsDeleteSessionResource,
+        )
+
+    def add(
+        self,
+        session_id: str,
+        *,
+        file_id: str,
+        type: Literal["file"],
+        mount_path: Optional[str] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsFileResource:
+        """
+        Add Session Resource
+
+        Args:
+          file_id: ID of a previously uploaded file.
+
+          mount_path: Mount path in the container. Defaults to `/mnt/session/uploads/<file_id>`.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._post(
+            path_template("/v1/sessions/{session_id}/resources?beta=true", session_id=session_id),
+            body=maybe_transform(
+                {
+                    "file_id": file_id,
+                    "type": type,
+                    "mount_path": mount_path,
+                },
+                resource_add_params.ResourceAddParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsFileResource,
+        )
+
+
+class AsyncResources(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncResourcesWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncResourcesWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncResourcesWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return AsyncResourcesWithStreamingResponse(self)
+
+    async def retrieve(
+        self,
+        resource_id: str,
+        *,
+        session_id: str,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ResourceRetrieveResponse:
+        """
+        Get Session Resource
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        if not resource_id:
+            raise ValueError(f"Expected a non-empty value for `resource_id` but received {resource_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return cast(
+            ResourceRetrieveResponse,
+            await self._get(
+                path_template(
+                    "/v1/sessions/{session_id}/resources/{resource_id}?beta=true",
+                    session_id=session_id,
+                    resource_id=resource_id,
+                ),
+                options=make_request_options(
+                    extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                ),
+                cast_to=cast(
+                    Any, ResourceRetrieveResponse
+                ),  # Union types cannot be passed in as arguments in the type system
+            ),
+        )
+
+    async def update(
+        self,
+        resource_id: str,
+        *,
+        session_id: str,
+        authorization_token: str,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ResourceUpdateResponse:
+        """
+        Update Session Resource
+
+        Args:
+          authorization_token: New authorization token for the resource. Currently only `github_repository`
+              resources support token rotation.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        if not resource_id:
+            raise ValueError(f"Expected a non-empty value for `resource_id` but received {resource_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return cast(
+            ResourceUpdateResponse,
+            await self._post(
+                path_template(
+                    "/v1/sessions/{session_id}/resources/{resource_id}?beta=true",
+                    session_id=session_id,
+                    resource_id=resource_id,
+                ),
+                body=await async_maybe_transform(
+                    {"authorization_token": authorization_token}, resource_update_params.ResourceUpdateParams
+                ),
+                options=make_request_options(
+                    extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                ),
+                cast_to=cast(
+                    Any, ResourceUpdateResponse
+                ),  # Union types cannot be passed in as arguments in the type system
+            ),
+        )
+
+    def list(
+        self,
+        session_id: str,
+        *,
+        limit: int | Omit = omit,
+        page: str | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[BetaManagedAgentsSessionResource, AsyncPageCursor[BetaManagedAgentsSessionResource]]:
+        """
+        List Session Resources
+
+        Args:
+          limit: Maximum number of resources to return per page (max 1000). If omitted, returns
+              all resources.
+
+          page: Opaque cursor from a previous response's next_page field.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._get_api_list(
+            path_template("/v1/sessions/{session_id}/resources?beta=true", session_id=session_id),
+            page=AsyncPageCursor[BetaManagedAgentsSessionResource],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "limit": limit,
+                        "page": page,
+                    },
+                    resource_list_params.ResourceListParams,
+                ),
+            ),
+            model=cast(
+                Any, BetaManagedAgentsSessionResource
+            ),  # Union types cannot be passed in as arguments in the type system
+        )
+
+    async def delete(
+        self,
+        resource_id: str,
+        *,
+        session_id: str,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsDeleteSessionResource:
+        """
+        Delete Session Resource
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        if not resource_id:
+            raise ValueError(f"Expected a non-empty value for `resource_id` but received {resource_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._delete(
+            path_template(
+                "/v1/sessions/{session_id}/resources/{resource_id}?beta=true",
+                session_id=session_id,
+                resource_id=resource_id,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsDeleteSessionResource,
+        )
+
+    async def add(
+        self,
+        session_id: str,
+        *,
+        file_id: str,
+        type: Literal["file"],
+        mount_path: Optional[str] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsFileResource:
+        """
+        Add Session Resource
+
+        Args:
+          file_id: ID of a previously uploaded file.
+
+          mount_path: Mount path in the container. Defaults to `/mnt/session/uploads/<file_id>`.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._post(
+            path_template("/v1/sessions/{session_id}/resources?beta=true", session_id=session_id),
+            body=await async_maybe_transform(
+                {
+                    "file_id": file_id,
+                    "type": type,
+                    "mount_path": mount_path,
+                },
+                resource_add_params.ResourceAddParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsFileResource,
+        )
+
+
+class ResourcesWithRawResponse:
+    def __init__(self, resources: Resources) -> None:
+        self._resources = resources
+
+        self.retrieve = _legacy_response.to_raw_response_wrapper(
+            resources.retrieve,
+        )
+        self.update = _legacy_response.to_raw_response_wrapper(
+            resources.update,
+        )
+        self.list = _legacy_response.to_raw_response_wrapper(
+            resources.list,
+        )
+        self.delete = _legacy_response.to_raw_response_wrapper(
+            resources.delete,
+        )
+        self.add = _legacy_response.to_raw_response_wrapper(
+            resources.add,
+        )
+
+
+class AsyncResourcesWithRawResponse:
+    def __init__(self, resources: AsyncResources) -> None:
+        self._resources = resources
+
+        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
+            resources.retrieve,
+        )
+        self.update = _legacy_response.async_to_raw_response_wrapper(
+            resources.update,
+        )
+        self.list = _legacy_response.async_to_raw_response_wrapper(
+            resources.list,
+        )
+        self.delete = _legacy_response.async_to_raw_response_wrapper(
+            resources.delete,
+        )
+        self.add = _legacy_response.async_to_raw_response_wrapper(
+            resources.add,
+        )
+
+
+class ResourcesWithStreamingResponse:
+    def __init__(self, resources: Resources) -> None:
+        self._resources = resources
+
+        self.retrieve = to_streamed_response_wrapper(
+            resources.retrieve,
+        )
+        self.update = to_streamed_response_wrapper(
+            resources.update,
+        )
+        self.list = to_streamed_response_wrapper(
+            resources.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            resources.delete,
+        )
+        self.add = to_streamed_response_wrapper(
+            resources.add,
+        )
+
+
+class AsyncResourcesWithStreamingResponse:
+    def __init__(self, resources: AsyncResources) -> None:
+        self._resources = resources
+
+        self.retrieve = async_to_streamed_response_wrapper(
+            resources.retrieve,
+        )
+        self.update = async_to_streamed_response_wrapper(
+            resources.update,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            resources.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            resources.delete,
+        )
+        self.add = async_to_streamed_response_wrapper(
+            resources.add,
+        )

venv/lib/python3.12/site-packages/anthropic/resources/beta/sessions/sessions.py

@@ -0,0 +1,983 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, List, Union, Iterable, Optional
+from datetime import datetime
+from itertools import chain
+from typing_extensions import Literal
+
+import httpx
+
+from .... import _legacy_response
+from .events import (
+    Events,
+    AsyncEvents,
+    EventsWithRawResponse,
+    AsyncEventsWithRawResponse,
+    EventsWithStreamingResponse,
+    AsyncEventsWithStreamingResponse,
+)
+from ...._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given
+from ...._utils import is_given, path_template, maybe_transform, strip_not_given, async_maybe_transform
+from .resources import (
+    Resources,
+    AsyncResources,
+    ResourcesWithRawResponse,
+    AsyncResourcesWithRawResponse,
+    ResourcesWithStreamingResponse,
+    AsyncResourcesWithStreamingResponse,
+)
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ....pagination import SyncPageCursor, AsyncPageCursor
+from ....types.beta import session_list_params, session_create_params, session_update_params
+from ...._base_client import AsyncPaginator, make_request_options
+from ....types.anthropic_beta_param import AnthropicBetaParam
+from ....types.beta.beta_managed_agents_session import BetaManagedAgentsSession
+from ....types.beta.beta_managed_agents_deleted_session import BetaManagedAgentsDeletedSession
+
+__all__ = ["Sessions", "AsyncSessions"]
+
+
+class Sessions(SyncAPIResource):
+    @cached_property
+    def events(self) -> Events:
+        return Events(self._client)
+
+    @cached_property
+    def resources(self) -> Resources:
+        return Resources(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> SessionsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return SessionsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> SessionsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return SessionsWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        agent: session_create_params.Agent,
+        environment_id: str,
+        metadata: Dict[str, str] | Omit = omit,
+        resources: Iterable[session_create_params.Resource] | Omit = omit,
+        title: Optional[str] | Omit = omit,
+        vault_ids: SequenceNotStr[str] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsSession:
+        """Create Session
+
+        Args:
+          agent: Agent identifier.
+
+        Accepts the `agent` ID string, which pins the latest version
+              for the session, or an `agent` object with both id and version specified.
+
+          environment_id: ID of the `environment` defining the container configuration for this session.
+
+          metadata: Arbitrary key-value metadata attached to the session. Maximum 16 pairs, keys up
+              to 64 chars, values up to 512 chars.
+
+          resources: Resources (e.g. repositories, files) to mount into the session's container.
+
+          title: Human-readable session title.
+
+          vault_ids: Vault IDs for stored credentials the agent can use during the session.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._post(
+            "/v1/sessions?beta=true",
+            body=maybe_transform(
+                {
+                    "agent": agent,
+                    "environment_id": environment_id,
+                    "metadata": metadata,
+                    "resources": resources,
+                    "title": title,
+                    "vault_ids": vault_ids,
+                },
+                session_create_params.SessionCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsSession,
+        )
+
+    def retrieve(
+        self,
+        session_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsSession:
+        """
+        Get Session
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._get(
+            path_template("/v1/sessions/{session_id}?beta=true", session_id=session_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsSession,
+        )
+
+    def update(
+        self,
+        session_id: str,
+        *,
+        metadata: Optional[Dict[str, Optional[str]]] | Omit = omit,
+        title: Optional[str] | Omit = omit,
+        vault_ids: SequenceNotStr[str] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsSession:
+        """Update Session
+
+        Args:
+          metadata: Metadata patch.
+
+        Set a key to a string to upsert it, or to null to delete it.
+              Omit the field to preserve.
+
+          title: Human-readable session title.
+
+          vault_ids: Vault IDs (`vlt_*`) to attach to the session. Not yet supported; requests
+              setting this field are rejected. Reserved for future use.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._post(
+            path_template("/v1/sessions/{session_id}?beta=true", session_id=session_id),
+            body=maybe_transform(
+                {
+                    "metadata": metadata,
+                    "title": title,
+                    "vault_ids": vault_ids,
+                },
+                session_update_params.SessionUpdateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsSession,
+        )
+
+    def list(
+        self,
+        *,
+        agent_id: str | Omit = omit,
+        agent_version: int | Omit = omit,
+        created_at_gt: Union[str, datetime] | Omit = omit,
+        created_at_gte: Union[str, datetime] | Omit = omit,
+        created_at_lt: Union[str, datetime] | Omit = omit,
+        created_at_lte: Union[str, datetime] | Omit = omit,
+        include_archived: bool | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        page: str | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncPageCursor[BetaManagedAgentsSession]:
+        """
+        List Sessions
+
+        Args:
+          agent_id: Filter sessions created with this agent ID.
+
+          agent_version: Filter by agent version. Only applies when agent_id is also set.
+
+          created_at_gt: Return sessions created after this time (exclusive).
+
+          created_at_gte: Return sessions created at or after this time (inclusive).
+
+          created_at_lt: Return sessions created before this time (exclusive).
+
+          created_at_lte: Return sessions created at or before this time (inclusive).
+
+          include_archived: When true, includes archived sessions. Default: false (exclude archived).
+
+          limit: Maximum number of results to return.
+
+          order: Sort direction for results, ordered by created_at. Defaults to desc (newest
+              first).
+
+          page: Opaque pagination cursor from a previous response's next_page.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._get_api_list(
+            "/v1/sessions?beta=true",
+            page=SyncPageCursor[BetaManagedAgentsSession],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "agent_id": agent_id,
+                        "agent_version": agent_version,
+                        "created_at_gt": created_at_gt,
+                        "created_at_gte": created_at_gte,
+                        "created_at_lt": created_at_lt,
+                        "created_at_lte": created_at_lte,
+                        "include_archived": include_archived,
+                        "limit": limit,
+                        "order": order,
+                        "page": page,
+                    },
+                    session_list_params.SessionListParams,
+                ),
+            ),
+            model=BetaManagedAgentsSession,
+        )
+
+    def delete(
+        self,
+        session_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsDeletedSession:
+        """
+        Delete Session
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._delete(
+            path_template("/v1/sessions/{session_id}?beta=true", session_id=session_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsDeletedSession,
+        )
+
+    def archive(
+        self,
+        session_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsSession:
+        """
+        Archive Session
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._post(
+            path_template("/v1/sessions/{session_id}/archive?beta=true", session_id=session_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsSession,
+        )
+
+
+class AsyncSessions(AsyncAPIResource):
+    @cached_property
+    def events(self) -> AsyncEvents:
+        return AsyncEvents(self._client)
+
+    @cached_property
+    def resources(self) -> AsyncResources:
+        return AsyncResources(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncSessionsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncSessionsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncSessionsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return AsyncSessionsWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        agent: session_create_params.Agent,
+        environment_id: str,
+        metadata: Dict[str, str] | Omit = omit,
+        resources: Iterable[session_create_params.Resource] | Omit = omit,
+        title: Optional[str] | Omit = omit,
+        vault_ids: SequenceNotStr[str] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsSession:
+        """Create Session
+
+        Args:
+          agent: Agent identifier.
+
+        Accepts the `agent` ID string, which pins the latest version
+              for the session, or an `agent` object with both id and version specified.
+
+          environment_id: ID of the `environment` defining the container configuration for this session.
+
+          metadata: Arbitrary key-value metadata attached to the session. Maximum 16 pairs, keys up
+              to 64 chars, values up to 512 chars.
+
+          resources: Resources (e.g. repositories, files) to mount into the session's container.
+
+          title: Human-readable session title.
+
+          vault_ids: Vault IDs for stored credentials the agent can use during the session.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._post(
+            "/v1/sessions?beta=true",
+            body=await async_maybe_transform(
+                {
+                    "agent": agent,
+                    "environment_id": environment_id,
+                    "metadata": metadata,
+                    "resources": resources,
+                    "title": title,
+                    "vault_ids": vault_ids,
+                },
+                session_create_params.SessionCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsSession,
+        )
+
+    async def retrieve(
+        self,
+        session_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsSession:
+        """
+        Get Session
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._get(
+            path_template("/v1/sessions/{session_id}?beta=true", session_id=session_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsSession,
+        )
+
+    async def update(
+        self,
+        session_id: str,
+        *,
+        metadata: Optional[Dict[str, Optional[str]]] | Omit = omit,
+        title: Optional[str] | Omit = omit,
+        vault_ids: SequenceNotStr[str] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsSession:
+        """Update Session
+
+        Args:
+          metadata: Metadata patch.
+
+        Set a key to a string to upsert it, or to null to delete it.
+              Omit the field to preserve.
+
+          title: Human-readable session title.
+
+          vault_ids: Vault IDs (`vlt_*`) to attach to the session. Not yet supported; requests
+              setting this field are rejected. Reserved for future use.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._post(
+            path_template("/v1/sessions/{session_id}?beta=true", session_id=session_id),
+            body=await async_maybe_transform(
+                {
+                    "metadata": metadata,
+                    "title": title,
+                    "vault_ids": vault_ids,
+                },
+                session_update_params.SessionUpdateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsSession,
+        )
+
+    def list(
+        self,
+        *,
+        agent_id: str | Omit = omit,
+        agent_version: int | Omit = omit,
+        created_at_gt: Union[str, datetime] | Omit = omit,
+        created_at_gte: Union[str, datetime] | Omit = omit,
+        created_at_lt: Union[str, datetime] | Omit = omit,
+        created_at_lte: Union[str, datetime] | Omit = omit,
+        include_archived: bool | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        page: str | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[BetaManagedAgentsSession, AsyncPageCursor[BetaManagedAgentsSession]]:
+        """
+        List Sessions
+
+        Args:
+          agent_id: Filter sessions created with this agent ID.
+
+          agent_version: Filter by agent version. Only applies when agent_id is also set.
+
+          created_at_gt: Return sessions created after this time (exclusive).
+
+          created_at_gte: Return sessions created at or after this time (inclusive).
+
+          created_at_lt: Return sessions created before this time (exclusive).
+
+          created_at_lte: Return sessions created at or before this time (inclusive).
+
+          include_archived: When true, includes archived sessions. Default: false (exclude archived).
+
+          limit: Maximum number of results to return.
+
+          order: Sort direction for results, ordered by created_at. Defaults to desc (newest
+              first).
+
+          page: Opaque pagination cursor from a previous response's next_page.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._get_api_list(
+            "/v1/sessions?beta=true",
+            page=AsyncPageCursor[BetaManagedAgentsSession],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "agent_id": agent_id,
+                        "agent_version": agent_version,
+                        "created_at_gt": created_at_gt,
+                        "created_at_gte": created_at_gte,
+                        "created_at_lt": created_at_lt,
+                        "created_at_lte": created_at_lte,
+                        "include_archived": include_archived,
+                        "limit": limit,
+                        "order": order,
+                        "page": page,
+                    },
+                    session_list_params.SessionListParams,
+                ),
+            ),
+            model=BetaManagedAgentsSession,
+        )
+
+    async def delete(
+        self,
+        session_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsDeletedSession:
+        """
+        Delete Session
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._delete(
+            path_template("/v1/sessions/{session_id}?beta=true", session_id=session_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsDeletedSession,
+        )
+
+    async def archive(
+        self,
+        session_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsSession:
+        """
+        Archive Session
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._post(
+            path_template("/v1/sessions/{session_id}/archive?beta=true", session_id=session_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsSession,
+        )
+
+
+class SessionsWithRawResponse:
+    def __init__(self, sessions: Sessions) -> None:
+        self._sessions = sessions
+
+        self.create = _legacy_response.to_raw_response_wrapper(
+            sessions.create,
+        )
+        self.retrieve = _legacy_response.to_raw_response_wrapper(
+            sessions.retrieve,
+        )
+        self.update = _legacy_response.to_raw_response_wrapper(
+            sessions.update,
+        )
+        self.list = _legacy_response.to_raw_response_wrapper(
+            sessions.list,
+        )
+        self.delete = _legacy_response.to_raw_response_wrapper(
+            sessions.delete,
+        )
+        self.archive = _legacy_response.to_raw_response_wrapper(
+            sessions.archive,
+        )
+
+    @cached_property
+    def events(self) -> EventsWithRawResponse:
+        return EventsWithRawResponse(self._sessions.events)
+
+    @cached_property
+    def resources(self) -> ResourcesWithRawResponse:
+        return ResourcesWithRawResponse(self._sessions.resources)
+
+
+class AsyncSessionsWithRawResponse:
+    def __init__(self, sessions: AsyncSessions) -> None:
+        self._sessions = sessions
+
+        self.create = _legacy_response.async_to_raw_response_wrapper(
+            sessions.create,
+        )
+        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
+            sessions.retrieve,
+        )
+        self.update = _legacy_response.async_to_raw_response_wrapper(
+            sessions.update,
+        )
+        self.list = _legacy_response.async_to_raw_response_wrapper(
+            sessions.list,
+        )
+        self.delete = _legacy_response.async_to_raw_response_wrapper(
+            sessions.delete,
+        )
+        self.archive = _legacy_response.async_to_raw_response_wrapper(
+            sessions.archive,
+        )
+
+    @cached_property
+    def events(self) -> AsyncEventsWithRawResponse:
+        return AsyncEventsWithRawResponse(self._sessions.events)
+
+    @cached_property
+    def resources(self) -> AsyncResourcesWithRawResponse:
+        return AsyncResourcesWithRawResponse(self._sessions.resources)
+
+
+class SessionsWithStreamingResponse:
+    def __init__(self, sessions: Sessions) -> None:
+        self._sessions = sessions
+
+        self.create = to_streamed_response_wrapper(
+            sessions.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            sessions.retrieve,
+        )
+        self.update = to_streamed_response_wrapper(
+            sessions.update,
+        )
+        self.list = to_streamed_response_wrapper(
+            sessions.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            sessions.delete,
+        )
+        self.archive = to_streamed_response_wrapper(
+            sessions.archive,
+        )
+
+    @cached_property
+    def events(self) -> EventsWithStreamingResponse:
+        return EventsWithStreamingResponse(self._sessions.events)
+
+    @cached_property
+    def resources(self) -> ResourcesWithStreamingResponse:
+        return ResourcesWithStreamingResponse(self._sessions.resources)
+
+
+class AsyncSessionsWithStreamingResponse:
+    def __init__(self, sessions: AsyncSessions) -> None:
+        self._sessions = sessions
+
+        self.create = async_to_streamed_response_wrapper(
+            sessions.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            sessions.retrieve,
+        )
+        self.update = async_to_streamed_response_wrapper(
+            sessions.update,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            sessions.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            sessions.delete,
+        )
+        self.archive = async_to_streamed_response_wrapper(
+            sessions.archive,
+        )
+
+    @cached_property
+    def events(self) -> AsyncEventsWithStreamingResponse:
+        return AsyncEventsWithStreamingResponse(self._sessions.events)
+
+    @cached_property
+    def resources(self) -> AsyncResourcesWithStreamingResponse:
+        return AsyncResourcesWithStreamingResponse(self._sessions.resources)

venv/lib/python3.12/site-packages/anthropic/resources/beta/skills/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .skills import (
+    Skills,
+    AsyncSkills,
+    SkillsWithRawResponse,
+    AsyncSkillsWithRawResponse,
+    SkillsWithStreamingResponse,
+    AsyncSkillsWithStreamingResponse,
+)
+from .versions import (
+    Versions,
+    AsyncVersions,
+    VersionsWithRawResponse,
+    AsyncVersionsWithRawResponse,
+    VersionsWithStreamingResponse,
+    AsyncVersionsWithStreamingResponse,
+)
+
+__all__ = [
+    "Versions",
+    "AsyncVersions",
+    "VersionsWithRawResponse",
+    "AsyncVersionsWithRawResponse",
+    "VersionsWithStreamingResponse",
+    "AsyncVersionsWithStreamingResponse",
+    "Skills",
+    "AsyncSkills",
+    "SkillsWithRawResponse",
+    "AsyncSkillsWithRawResponse",
+    "SkillsWithStreamingResponse",
+    "AsyncSkillsWithStreamingResponse",
+]

venv/lib/python3.12/site-packages/anthropic/resources/beta/skills/skills.py

@@ -0,0 +1,681 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Mapping, Optional, cast
+from itertools import chain
+
+import httpx
+
+from .... import _legacy_response
+from .versions import (
+    Versions,
+    AsyncVersions,
+    VersionsWithRawResponse,
+    AsyncVersionsWithRawResponse,
+    VersionsWithStreamingResponse,
+    AsyncVersionsWithStreamingResponse,
+)
+from ...._types import (
+    Body,
+    Omit,
+    Query,
+    Headers,
+    NotGiven,
+    FileTypes,
+    SequenceNotStr,
+    omit,
+    not_given,
+)
+from ...._utils import (
+    is_given,
+    extract_files,
+    path_template,
+    maybe_transform,
+    strip_not_given,
+    deepcopy_minimal,
+    async_maybe_transform,
+)
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ....pagination import SyncPageCursor, AsyncPageCursor
+from ....types.beta import skill_list_params, skill_create_params
+from ...._base_client import AsyncPaginator, make_request_options
+from ....types.anthropic_beta_param import AnthropicBetaParam
+from ....types.beta.skill_list_response import SkillListResponse
+from ....types.beta.skill_create_response import SkillCreateResponse
+from ....types.beta.skill_delete_response import SkillDeleteResponse
+from ....types.beta.skill_retrieve_response import SkillRetrieveResponse
+
+__all__ = ["Skills", "AsyncSkills"]
+
+
+class Skills(SyncAPIResource):
+    @cached_property
+    def versions(self) -> Versions:
+        return Versions(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> SkillsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return SkillsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> SkillsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return SkillsWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        display_title: Optional[str] | Omit = omit,
+        files: Optional[SequenceNotStr[FileTypes]] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SkillCreateResponse:
+        """
+        Create Skill
+
+        Args:
+          display_title: Display title for the skill.
+
+              This is a human-readable label that is not included in the prompt sent to the
+              model.
+
+          files: Files to upload for the skill.
+
+              All files must be in the same top-level directory and must include a SKILL.md
+              file at the root of that directory.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["skills-2025-10-02"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "skills-2025-10-02", **(extra_headers or {})}
+        body = deepcopy_minimal(
+            {
+                "display_title": display_title,
+                "files": files,
+            }
+        )
+        extracted_files = extract_files(cast(Mapping[str, object], body), paths=[["files", "<array>"]])
+        # It should be noted that the actual Content-Type header that will be
+        # sent to the server will contain a `boundary` parameter, e.g.
+        # multipart/form-data; boundary=---abc--
+        extra_headers["Content-Type"] = "multipart/form-data"
+        return self._post(
+            "/v1/skills?beta=true",
+            body=maybe_transform(body, skill_create_params.SkillCreateParams),
+            files=extracted_files,
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SkillCreateResponse,
+        )
+
+    def retrieve(
+        self,
+        skill_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SkillRetrieveResponse:
+        """
+        Get Skill
+
+        Args:
+          skill_id: Unique identifier for the skill.
+
+              The format and length of IDs may change over time.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not skill_id:
+            raise ValueError(f"Expected a non-empty value for `skill_id` but received {skill_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["skills-2025-10-02"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "skills-2025-10-02", **(extra_headers or {})}
+        return self._get(
+            path_template("/v1/skills/{skill_id}?beta=true", skill_id=skill_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SkillRetrieveResponse,
+        )
+
+    def list(
+        self,
+        *,
+        limit: int | Omit = omit,
+        page: Optional[str] | Omit = omit,
+        source: Optional[str] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncPageCursor[SkillListResponse]:
+        """
+        List Skills
+
+        Args:
+          limit: Number of results to return per page.
+
+              Maximum value is 100. Defaults to 20.
+
+          page: Pagination token for fetching a specific page of results.
+
+              Pass the value from a previous response's `next_page` field to get the next page
+              of results.
+
+          source: Filter skills by source.
+
+              If provided, only skills from the specified source will be returned:
+
+              - `"custom"`: only return user-created skills
+              - `"anthropic"`: only return Anthropic-created skills
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["skills-2025-10-02"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "skills-2025-10-02", **(extra_headers or {})}
+        return self._get_api_list(
+            "/v1/skills?beta=true",
+            page=SyncPageCursor[SkillListResponse],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "limit": limit,
+                        "page": page,
+                        "source": source,
+                    },
+                    skill_list_params.SkillListParams,
+                ),
+            ),
+            model=SkillListResponse,
+        )
+
+    def delete(
+        self,
+        skill_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SkillDeleteResponse:
+        """
+        Delete Skill
+
+        Args:
+          skill_id: Unique identifier for the skill.
+
+              The format and length of IDs may change over time.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not skill_id:
+            raise ValueError(f"Expected a non-empty value for `skill_id` but received {skill_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["skills-2025-10-02"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "skills-2025-10-02", **(extra_headers or {})}
+        return self._delete(
+            path_template("/v1/skills/{skill_id}?beta=true", skill_id=skill_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SkillDeleteResponse,
+        )
+
+
+class AsyncSkills(AsyncAPIResource):
+    @cached_property
+    def versions(self) -> AsyncVersions:
+        return AsyncVersions(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncSkillsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncSkillsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncSkillsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return AsyncSkillsWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        display_title: Optional[str] | Omit = omit,
+        files: Optional[SequenceNotStr[FileTypes]] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SkillCreateResponse:
+        """
+        Create Skill
+
+        Args:
+          display_title: Display title for the skill.
+
+              This is a human-readable label that is not included in the prompt sent to the
+              model.
+
+          files: Files to upload for the skill.
+
+              All files must be in the same top-level directory and must include a SKILL.md
+              file at the root of that directory.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["skills-2025-10-02"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "skills-2025-10-02", **(extra_headers or {})}
+        body = deepcopy_minimal(
+            {
+                "display_title": display_title,
+                "files": files,
+            }
+        )
+        extracted_files = extract_files(cast(Mapping[str, object], body), paths=[["files", "<array>"]])
+        # It should be noted that the actual Content-Type header that will be
+        # sent to the server will contain a `boundary` parameter, e.g.
+        # multipart/form-data; boundary=---abc--
+        extra_headers["Content-Type"] = "multipart/form-data"
+        return await self._post(
+            "/v1/skills?beta=true",
+            body=await async_maybe_transform(body, skill_create_params.SkillCreateParams),
+            files=extracted_files,
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SkillCreateResponse,
+        )
+
+    async def retrieve(
+        self,
+        skill_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SkillRetrieveResponse:
+        """
+        Get Skill
+
+        Args:
+          skill_id: Unique identifier for the skill.
+
+              The format and length of IDs may change over time.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not skill_id:
+            raise ValueError(f"Expected a non-empty value for `skill_id` but received {skill_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["skills-2025-10-02"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "skills-2025-10-02", **(extra_headers or {})}
+        return await self._get(
+            path_template("/v1/skills/{skill_id}?beta=true", skill_id=skill_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SkillRetrieveResponse,
+        )
+
+    def list(
+        self,
+        *,
+        limit: int | Omit = omit,
+        page: Optional[str] | Omit = omit,
+        source: Optional[str] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[SkillListResponse, AsyncPageCursor[SkillListResponse]]:
+        """
+        List Skills
+
+        Args:
+          limit: Number of results to return per page.
+
+              Maximum value is 100. Defaults to 20.
+
+          page: Pagination token for fetching a specific page of results.
+
+              Pass the value from a previous response's `next_page` field to get the next page
+              of results.
+
+          source: Filter skills by source.
+
+              If provided, only skills from the specified source will be returned:
+
+              - `"custom"`: only return user-created skills
+              - `"anthropic"`: only return Anthropic-created skills
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["skills-2025-10-02"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "skills-2025-10-02", **(extra_headers or {})}
+        return self._get_api_list(
+            "/v1/skills?beta=true",
+            page=AsyncPageCursor[SkillListResponse],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "limit": limit,
+                        "page": page,
+                        "source": source,
+                    },
+                    skill_list_params.SkillListParams,
+                ),
+            ),
+            model=SkillListResponse,
+        )
+
+    async def delete(
+        self,
+        skill_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SkillDeleteResponse:
+        """
+        Delete Skill
+
+        Args:
+          skill_id: Unique identifier for the skill.
+
+              The format and length of IDs may change over time.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not skill_id:
+            raise ValueError(f"Expected a non-empty value for `skill_id` but received {skill_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["skills-2025-10-02"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "skills-2025-10-02", **(extra_headers or {})}
+        return await self._delete(
+            path_template("/v1/skills/{skill_id}?beta=true", skill_id=skill_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SkillDeleteResponse,
+        )
+
+
+class SkillsWithRawResponse:
+    def __init__(self, skills: Skills) -> None:
+        self._skills = skills
+
+        self.create = _legacy_response.to_raw_response_wrapper(
+            skills.create,
+        )
+        self.retrieve = _legacy_response.to_raw_response_wrapper(
+            skills.retrieve,
+        )
+        self.list = _legacy_response.to_raw_response_wrapper(
+            skills.list,
+        )
+        self.delete = _legacy_response.to_raw_response_wrapper(
+            skills.delete,
+        )
+
+    @cached_property
+    def versions(self) -> VersionsWithRawResponse:
+        return VersionsWithRawResponse(self._skills.versions)
+
+
+class AsyncSkillsWithRawResponse:
+    def __init__(self, skills: AsyncSkills) -> None:
+        self._skills = skills
+
+        self.create = _legacy_response.async_to_raw_response_wrapper(
+            skills.create,
+        )
+        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
+            skills.retrieve,
+        )
+        self.list = _legacy_response.async_to_raw_response_wrapper(
+            skills.list,
+        )
+        self.delete = _legacy_response.async_to_raw_response_wrapper(
+            skills.delete,
+        )
+
+    @cached_property
+    def versions(self) -> AsyncVersionsWithRawResponse:
+        return AsyncVersionsWithRawResponse(self._skills.versions)
+
+
+class SkillsWithStreamingResponse:
+    def __init__(self, skills: Skills) -> None:
+        self._skills = skills
+
+        self.create = to_streamed_response_wrapper(
+            skills.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            skills.retrieve,
+        )
+        self.list = to_streamed_response_wrapper(
+            skills.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            skills.delete,
+        )
+
+    @cached_property
+    def versions(self) -> VersionsWithStreamingResponse:
+        return VersionsWithStreamingResponse(self._skills.versions)
+
+
+class AsyncSkillsWithStreamingResponse:
+    def __init__(self, skills: AsyncSkills) -> None:
+        self._skills = skills
+
+        self.create = async_to_streamed_response_wrapper(
+            skills.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            skills.retrieve,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            skills.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            skills.delete,
+        )
+
+    @cached_property
+    def versions(self) -> AsyncVersionsWithStreamingResponse:
+        return AsyncVersionsWithStreamingResponse(self._skills.versions)

venv/lib/python3.12/site-packages/anthropic/resources/beta/skills/versions.py

@@ -0,0 +1,659 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Mapping, Optional, cast
+from itertools import chain
+
+import httpx
+
+from .... import _legacy_response
+from ...._types import (
+    Body,
+    Omit,
+    Query,
+    Headers,
+    NotGiven,
+    FileTypes,
+    SequenceNotStr,
+    omit,
+    not_given,
+)
+from ...._utils import (
+    is_given,
+    extract_files,
+    path_template,
+    maybe_transform,
+    strip_not_given,
+    deepcopy_minimal,
+    async_maybe_transform,
+)
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ....pagination import SyncPageCursor, AsyncPageCursor
+from ...._base_client import AsyncPaginator, make_request_options
+from ....types.beta.skills import version_list_params, version_create_params
+from ....types.anthropic_beta_param import AnthropicBetaParam
+from ....types.beta.skills.version_list_response import VersionListResponse
+from ....types.beta.skills.version_create_response import VersionCreateResponse
+from ....types.beta.skills.version_delete_response import VersionDeleteResponse
+from ....types.beta.skills.version_retrieve_response import VersionRetrieveResponse
+
+__all__ = ["Versions", "AsyncVersions"]
+
+
+class Versions(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> VersionsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return VersionsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> VersionsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return VersionsWithStreamingResponse(self)
+
+    def create(
+        self,
+        skill_id: str,
+        *,
+        files: Optional[SequenceNotStr[FileTypes]] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> VersionCreateResponse:
+        """
+        Create Skill Version
+
+        Args:
+          skill_id: Unique identifier for the skill.
+
+              The format and length of IDs may change over time.
+
+          files: Files to upload for the skill.
+
+              All files must be in the same top-level directory and must include a SKILL.md
+              file at the root of that directory.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not skill_id:
+            raise ValueError(f"Expected a non-empty value for `skill_id` but received {skill_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["skills-2025-10-02"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "skills-2025-10-02", **(extra_headers or {})}
+        body = deepcopy_minimal({"files": files})
+        extracted_files = extract_files(cast(Mapping[str, object], body), paths=[["files", "<array>"]])
+        # It should be noted that the actual Content-Type header that will be
+        # sent to the server will contain a `boundary` parameter, e.g.
+        # multipart/form-data; boundary=---abc--
+        extra_headers["Content-Type"] = "multipart/form-data"
+        return self._post(
+            path_template("/v1/skills/{skill_id}/versions?beta=true", skill_id=skill_id),
+            body=maybe_transform(body, version_create_params.VersionCreateParams),
+            files=extracted_files,
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=VersionCreateResponse,
+        )
+
+    def retrieve(
+        self,
+        version: str,
+        *,
+        skill_id: str,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> VersionRetrieveResponse:
+        """
+        Get Skill Version
+
+        Args:
+          skill_id: Unique identifier for the skill.
+
+              The format and length of IDs may change over time.
+
+          version: Version identifier for the skill.
+
+              Each version is identified by a Unix epoch timestamp (e.g., "1759178010641129").
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not skill_id:
+            raise ValueError(f"Expected a non-empty value for `skill_id` but received {skill_id!r}")
+        if not version:
+            raise ValueError(f"Expected a non-empty value for `version` but received {version!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["skills-2025-10-02"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "skills-2025-10-02", **(extra_headers or {})}
+        return self._get(
+            path_template("/v1/skills/{skill_id}/versions/{version}?beta=true", skill_id=skill_id, version=version),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=VersionRetrieveResponse,
+        )
+
+    def list(
+        self,
+        skill_id: str,
+        *,
+        limit: Optional[int] | Omit = omit,
+        page: Optional[str] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncPageCursor[VersionListResponse]:
+        """
+        List Skill Versions
+
+        Args:
+          skill_id: Unique identifier for the skill.
+
+              The format and length of IDs may change over time.
+
+          limit: Number of items to return per page.
+
+              Defaults to `20`. Ranges from `1` to `1000`.
+
+          page: Optionally set to the `next_page` token from the previous response.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not skill_id:
+            raise ValueError(f"Expected a non-empty value for `skill_id` but received {skill_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["skills-2025-10-02"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "skills-2025-10-02", **(extra_headers or {})}
+        return self._get_api_list(
+            path_template("/v1/skills/{skill_id}/versions?beta=true", skill_id=skill_id),
+            page=SyncPageCursor[VersionListResponse],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "limit": limit,
+                        "page": page,
+                    },
+                    version_list_params.VersionListParams,
+                ),
+            ),
+            model=VersionListResponse,
+        )
+
+    def delete(
+        self,
+        version: str,
+        *,
+        skill_id: str,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> VersionDeleteResponse:
+        """
+        Delete Skill Version
+
+        Args:
+          skill_id: Unique identifier for the skill.
+
+              The format and length of IDs may change over time.
+
+          version: Version identifier for the skill.
+
+              Each version is identified by a Unix epoch timestamp (e.g., "1759178010641129").
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not skill_id:
+            raise ValueError(f"Expected a non-empty value for `skill_id` but received {skill_id!r}")
+        if not version:
+            raise ValueError(f"Expected a non-empty value for `version` but received {version!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["skills-2025-10-02"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "skills-2025-10-02", **(extra_headers or {})}
+        return self._delete(
+            path_template("/v1/skills/{skill_id}/versions/{version}?beta=true", skill_id=skill_id, version=version),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=VersionDeleteResponse,
+        )
+
+
+class AsyncVersions(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncVersionsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncVersionsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncVersionsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return AsyncVersionsWithStreamingResponse(self)
+
+    async def create(
+        self,
+        skill_id: str,
+        *,
+        files: Optional[SequenceNotStr[FileTypes]] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> VersionCreateResponse:
+        """
+        Create Skill Version
+
+        Args:
+          skill_id: Unique identifier for the skill.
+
+              The format and length of IDs may change over time.
+
+          files: Files to upload for the skill.
+
+              All files must be in the same top-level directory and must include a SKILL.md
+              file at the root of that directory.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not skill_id:
+            raise ValueError(f"Expected a non-empty value for `skill_id` but received {skill_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["skills-2025-10-02"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "skills-2025-10-02", **(extra_headers or {})}
+        body = deepcopy_minimal({"files": files})
+        extracted_files = extract_files(cast(Mapping[str, object], body), paths=[["files", "<array>"]])
+        # It should be noted that the actual Content-Type header that will be
+        # sent to the server will contain a `boundary` parameter, e.g.
+        # multipart/form-data; boundary=---abc--
+        extra_headers["Content-Type"] = "multipart/form-data"
+        return await self._post(
+            path_template("/v1/skills/{skill_id}/versions?beta=true", skill_id=skill_id),
+            body=await async_maybe_transform(body, version_create_params.VersionCreateParams),
+            files=extracted_files,
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=VersionCreateResponse,
+        )
+
+    async def retrieve(
+        self,
+        version: str,
+        *,
+        skill_id: str,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> VersionRetrieveResponse:
+        """
+        Get Skill Version
+
+        Args:
+          skill_id: Unique identifier for the skill.
+
+              The format and length of IDs may change over time.
+
+          version: Version identifier for the skill.
+
+              Each version is identified by a Unix epoch timestamp (e.g., "1759178010641129").
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not skill_id:
+            raise ValueError(f"Expected a non-empty value for `skill_id` but received {skill_id!r}")
+        if not version:
+            raise ValueError(f"Expected a non-empty value for `version` but received {version!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["skills-2025-10-02"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "skills-2025-10-02", **(extra_headers or {})}
+        return await self._get(
+            path_template("/v1/skills/{skill_id}/versions/{version}?beta=true", skill_id=skill_id, version=version),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=VersionRetrieveResponse,
+        )
+
+    def list(
+        self,
+        skill_id: str,
+        *,
+        limit: Optional[int] | Omit = omit,
+        page: Optional[str] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[VersionListResponse, AsyncPageCursor[VersionListResponse]]:
+        """
+        List Skill Versions
+
+        Args:
+          skill_id: Unique identifier for the skill.
+
+              The format and length of IDs may change over time.
+
+          limit: Number of items to return per page.
+
+              Defaults to `20`. Ranges from `1` to `1000`.
+
+          page: Optionally set to the `next_page` token from the previous response.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not skill_id:
+            raise ValueError(f"Expected a non-empty value for `skill_id` but received {skill_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["skills-2025-10-02"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "skills-2025-10-02", **(extra_headers or {})}
+        return self._get_api_list(
+            path_template("/v1/skills/{skill_id}/versions?beta=true", skill_id=skill_id),
+            page=AsyncPageCursor[VersionListResponse],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "limit": limit,
+                        "page": page,
+                    },
+                    version_list_params.VersionListParams,
+                ),
+            ),
+            model=VersionListResponse,
+        )
+
+    async def delete(
+        self,
+        version: str,
+        *,
+        skill_id: str,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> VersionDeleteResponse:
+        """
+        Delete Skill Version
+
+        Args:
+          skill_id: Unique identifier for the skill.
+
+              The format and length of IDs may change over time.
+
+          version: Version identifier for the skill.
+
+              Each version is identified by a Unix epoch timestamp (e.g., "1759178010641129").
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not skill_id:
+            raise ValueError(f"Expected a non-empty value for `skill_id` but received {skill_id!r}")
+        if not version:
+            raise ValueError(f"Expected a non-empty value for `version` but received {version!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["skills-2025-10-02"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "skills-2025-10-02", **(extra_headers or {})}
+        return await self._delete(
+            path_template("/v1/skills/{skill_id}/versions/{version}?beta=true", skill_id=skill_id, version=version),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=VersionDeleteResponse,
+        )
+
+
+class VersionsWithRawResponse:
+    def __init__(self, versions: Versions) -> None:
+        self._versions = versions
+
+        self.create = _legacy_response.to_raw_response_wrapper(
+            versions.create,
+        )
+        self.retrieve = _legacy_response.to_raw_response_wrapper(
+            versions.retrieve,
+        )
+        self.list = _legacy_response.to_raw_response_wrapper(
+            versions.list,
+        )
+        self.delete = _legacy_response.to_raw_response_wrapper(
+            versions.delete,
+        )
+
+
+class AsyncVersionsWithRawResponse:
+    def __init__(self, versions: AsyncVersions) -> None:
+        self._versions = versions
+
+        self.create = _legacy_response.async_to_raw_response_wrapper(
+            versions.create,
+        )
+        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
+            versions.retrieve,
+        )
+        self.list = _legacy_response.async_to_raw_response_wrapper(
+            versions.list,
+        )
+        self.delete = _legacy_response.async_to_raw_response_wrapper(
+            versions.delete,
+        )
+
+
+class VersionsWithStreamingResponse:
+    def __init__(self, versions: Versions) -> None:
+        self._versions = versions
+
+        self.create = to_streamed_response_wrapper(
+            versions.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            versions.retrieve,
+        )
+        self.list = to_streamed_response_wrapper(
+            versions.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            versions.delete,
+        )
+
+
+class AsyncVersionsWithStreamingResponse:
+    def __init__(self, versions: AsyncVersions) -> None:
+        self._versions = versions
+
+        self.create = async_to_streamed_response_wrapper(
+            versions.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            versions.retrieve,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            versions.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            versions.delete,
+        )

venv/lib/python3.12/site-packages/anthropic/resources/beta/user_profiles.py

@@ -0,0 +1,720 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, List, Optional
+from itertools import chain
+from typing_extensions import Literal
+
+import httpx
+
+from ... import _legacy_response
+from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ..._utils import is_given, path_template, maybe_transform, strip_not_given, async_maybe_transform
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from ..._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ...pagination import SyncPageCursor, AsyncPageCursor
+from ...types.beta import user_profile_list_params, user_profile_create_params, user_profile_update_params
+from ..._base_client import AsyncPaginator, make_request_options
+from ...types.anthropic_beta_param import AnthropicBetaParam
+from ...types.beta.beta_user_profile import BetaUserProfile
+from ...types.beta.beta_user_profile_enrollment_url import BetaUserProfileEnrollmentURL
+
+__all__ = ["UserProfiles", "AsyncUserProfiles"]
+
+
+class UserProfiles(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> UserProfilesWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return UserProfilesWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> UserProfilesWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return UserProfilesWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        external_id: Optional[str] | Omit = omit,
+        metadata: Dict[str, str] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaUserProfile:
+        """
+        Create User Profile
+
+        Args:
+          external_id: Platform's own identifier for this user. Not enforced unique. Maximum 255
+              characters.
+
+          metadata: Free-form key-value data to attach to this user profile. Maximum 16 keys, with
+              keys up to 64 characters and values up to 512 characters. Values must be
+              non-empty strings.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["user-profiles-2026-03-24"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "user-profiles-2026-03-24", **(extra_headers or {})}
+        return self._post(
+            "/v1/user_profiles?beta=true",
+            body=maybe_transform(
+                {
+                    "external_id": external_id,
+                    "metadata": metadata,
+                },
+                user_profile_create_params.UserProfileCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaUserProfile,
+        )
+
+    def retrieve(
+        self,
+        user_profile_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaUserProfile:
+        """
+        Get User Profile
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not user_profile_id:
+            raise ValueError(f"Expected a non-empty value for `user_profile_id` but received {user_profile_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["user-profiles-2026-03-24"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "user-profiles-2026-03-24", **(extra_headers or {})}
+        return self._get(
+            path_template("/v1/user_profiles/{user_profile_id}?beta=true", user_profile_id=user_profile_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaUserProfile,
+        )
+
+    def update(
+        self,
+        user_profile_id: str,
+        *,
+        external_id: Optional[str] | Omit = omit,
+        metadata: Dict[str, str] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaUserProfile:
+        """
+        Update User Profile
+
+        Args:
+          external_id: If present, replaces the stored external_id. Omit to leave unchanged. Maximum
+              255 characters.
+
+          metadata: Key-value pairs to merge into the stored metadata. Keys provided overwrite
+              existing values. To remove a key, set its value to an empty string. Keys not
+              provided are left unchanged. Maximum 16 keys, with keys up to 64 characters and
+              values up to 512 characters.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not user_profile_id:
+            raise ValueError(f"Expected a non-empty value for `user_profile_id` but received {user_profile_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["user-profiles-2026-03-24"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "user-profiles-2026-03-24", **(extra_headers or {})}
+        return self._post(
+            path_template("/v1/user_profiles/{user_profile_id}?beta=true", user_profile_id=user_profile_id),
+            body=maybe_transform(
+                {
+                    "external_id": external_id,
+                    "metadata": metadata,
+                },
+                user_profile_update_params.UserProfileUpdateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaUserProfile,
+        )
+
+    def list(
+        self,
+        *,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        page: str | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncPageCursor[BetaUserProfile]:
+        """
+        List User Profiles
+
+        Args:
+          limit: Query parameter for limit
+
+          order: Query parameter for order
+
+          page: Query parameter for page
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["user-profiles-2026-03-24"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "user-profiles-2026-03-24", **(extra_headers or {})}
+        return self._get_api_list(
+            "/v1/user_profiles?beta=true",
+            page=SyncPageCursor[BetaUserProfile],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "limit": limit,
+                        "order": order,
+                        "page": page,
+                    },
+                    user_profile_list_params.UserProfileListParams,
+                ),
+            ),
+            model=BetaUserProfile,
+        )
+
+    def create_enrollment_url(
+        self,
+        user_profile_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaUserProfileEnrollmentURL:
+        """
+        Create Enrollment URL
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not user_profile_id:
+            raise ValueError(f"Expected a non-empty value for `user_profile_id` but received {user_profile_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["user-profiles-2026-03-24"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "user-profiles-2026-03-24", **(extra_headers or {})}
+        return self._post(
+            path_template(
+                "/v1/user_profiles/{user_profile_id}/enrollment_url?beta=true", user_profile_id=user_profile_id
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaUserProfileEnrollmentURL,
+        )
+
+
+class AsyncUserProfiles(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncUserProfilesWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncUserProfilesWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncUserProfilesWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return AsyncUserProfilesWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        external_id: Optional[str] | Omit = omit,
+        metadata: Dict[str, str] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaUserProfile:
+        """
+        Create User Profile
+
+        Args:
+          external_id: Platform's own identifier for this user. Not enforced unique. Maximum 255
+              characters.
+
+          metadata: Free-form key-value data to attach to this user profile. Maximum 16 keys, with
+              keys up to 64 characters and values up to 512 characters. Values must be
+              non-empty strings.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["user-profiles-2026-03-24"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "user-profiles-2026-03-24", **(extra_headers or {})}
+        return await self._post(
+            "/v1/user_profiles?beta=true",
+            body=await async_maybe_transform(
+                {
+                    "external_id": external_id,
+                    "metadata": metadata,
+                },
+                user_profile_create_params.UserProfileCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaUserProfile,
+        )
+
+    async def retrieve(
+        self,
+        user_profile_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaUserProfile:
+        """
+        Get User Profile
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not user_profile_id:
+            raise ValueError(f"Expected a non-empty value for `user_profile_id` but received {user_profile_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["user-profiles-2026-03-24"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "user-profiles-2026-03-24", **(extra_headers or {})}
+        return await self._get(
+            path_template("/v1/user_profiles/{user_profile_id}?beta=true", user_profile_id=user_profile_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaUserProfile,
+        )
+
+    async def update(
+        self,
+        user_profile_id: str,
+        *,
+        external_id: Optional[str] | Omit = omit,
+        metadata: Dict[str, str] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaUserProfile:
+        """
+        Update User Profile
+
+        Args:
+          external_id: If present, replaces the stored external_id. Omit to leave unchanged. Maximum
+              255 characters.
+
+          metadata: Key-value pairs to merge into the stored metadata. Keys provided overwrite
+              existing values. To remove a key, set its value to an empty string. Keys not
+              provided are left unchanged. Maximum 16 keys, with keys up to 64 characters and
+              values up to 512 characters.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not user_profile_id:
+            raise ValueError(f"Expected a non-empty value for `user_profile_id` but received {user_profile_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["user-profiles-2026-03-24"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "user-profiles-2026-03-24", **(extra_headers or {})}
+        return await self._post(
+            path_template("/v1/user_profiles/{user_profile_id}?beta=true", user_profile_id=user_profile_id),
+            body=await async_maybe_transform(
+                {
+                    "external_id": external_id,
+                    "metadata": metadata,
+                },
+                user_profile_update_params.UserProfileUpdateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaUserProfile,
+        )
+
+    def list(
+        self,
+        *,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        page: str | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[BetaUserProfile, AsyncPageCursor[BetaUserProfile]]:
+        """
+        List User Profiles
+
+        Args:
+          limit: Query parameter for limit
+
+          order: Query parameter for order
+
+          page: Query parameter for page
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["user-profiles-2026-03-24"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "user-profiles-2026-03-24", **(extra_headers or {})}
+        return self._get_api_list(
+            "/v1/user_profiles?beta=true",
+            page=AsyncPageCursor[BetaUserProfile],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "limit": limit,
+                        "order": order,
+                        "page": page,
+                    },
+                    user_profile_list_params.UserProfileListParams,
+                ),
+            ),
+            model=BetaUserProfile,
+        )
+
+    async def create_enrollment_url(
+        self,
+        user_profile_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaUserProfileEnrollmentURL:
+        """
+        Create Enrollment URL
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not user_profile_id:
+            raise ValueError(f"Expected a non-empty value for `user_profile_id` but received {user_profile_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["user-profiles-2026-03-24"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "user-profiles-2026-03-24", **(extra_headers or {})}
+        return await self._post(
+            path_template(
+                "/v1/user_profiles/{user_profile_id}/enrollment_url?beta=true", user_profile_id=user_profile_id
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaUserProfileEnrollmentURL,
+        )
+
+
+class UserProfilesWithRawResponse:
+    def __init__(self, user_profiles: UserProfiles) -> None:
+        self._user_profiles = user_profiles
+
+        self.create = _legacy_response.to_raw_response_wrapper(
+            user_profiles.create,
+        )
+        self.retrieve = _legacy_response.to_raw_response_wrapper(
+            user_profiles.retrieve,
+        )
+        self.update = _legacy_response.to_raw_response_wrapper(
+            user_profiles.update,
+        )
+        self.list = _legacy_response.to_raw_response_wrapper(
+            user_profiles.list,
+        )
+        self.create_enrollment_url = _legacy_response.to_raw_response_wrapper(
+            user_profiles.create_enrollment_url,
+        )
+
+
+class AsyncUserProfilesWithRawResponse:
+    def __init__(self, user_profiles: AsyncUserProfiles) -> None:
+        self._user_profiles = user_profiles
+
+        self.create = _legacy_response.async_to_raw_response_wrapper(
+            user_profiles.create,
+        )
+        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
+            user_profiles.retrieve,
+        )
+        self.update = _legacy_response.async_to_raw_response_wrapper(
+            user_profiles.update,
+        )
+        self.list = _legacy_response.async_to_raw_response_wrapper(
+            user_profiles.list,
+        )
+        self.create_enrollment_url = _legacy_response.async_to_raw_response_wrapper(
+            user_profiles.create_enrollment_url,
+        )
+
+
+class UserProfilesWithStreamingResponse:
+    def __init__(self, user_profiles: UserProfiles) -> None:
+        self._user_profiles = user_profiles
+
+        self.create = to_streamed_response_wrapper(
+            user_profiles.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            user_profiles.retrieve,
+        )
+        self.update = to_streamed_response_wrapper(
+            user_profiles.update,
+        )
+        self.list = to_streamed_response_wrapper(
+            user_profiles.list,
+        )
+        self.create_enrollment_url = to_streamed_response_wrapper(
+            user_profiles.create_enrollment_url,
+        )
+
+
+class AsyncUserProfilesWithStreamingResponse:
+    def __init__(self, user_profiles: AsyncUserProfiles) -> None:
+        self._user_profiles = user_profiles
+
+        self.create = async_to_streamed_response_wrapper(
+            user_profiles.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            user_profiles.retrieve,
+        )
+        self.update = async_to_streamed_response_wrapper(
+            user_profiles.update,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            user_profiles.list,
+        )
+        self.create_enrollment_url = async_to_streamed_response_wrapper(
+            user_profiles.create_enrollment_url,
+        )

venv/lib/python3.12/site-packages/anthropic/resources/beta/vaults/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .vaults import (
+    Vaults,
+    AsyncVaults,
+    VaultsWithRawResponse,
+    AsyncVaultsWithRawResponse,
+    VaultsWithStreamingResponse,
+    AsyncVaultsWithStreamingResponse,
+)
+from .credentials import (
+    Credentials,
+    AsyncCredentials,
+    CredentialsWithRawResponse,
+    AsyncCredentialsWithRawResponse,
+    CredentialsWithStreamingResponse,
+    AsyncCredentialsWithStreamingResponse,
+)
+
+__all__ = [
+    "Credentials",
+    "AsyncCredentials",
+    "CredentialsWithRawResponse",
+    "AsyncCredentialsWithRawResponse",
+    "CredentialsWithStreamingResponse",
+    "AsyncCredentialsWithStreamingResponse",
+    "Vaults",
+    "AsyncVaults",
+    "VaultsWithRawResponse",
+    "AsyncVaultsWithRawResponse",
+    "VaultsWithStreamingResponse",
+    "AsyncVaultsWithStreamingResponse",
+]

venv/lib/python3.12/site-packages/anthropic/resources/beta/vaults/credentials.py

@@ -0,0 +1,895 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, List, Optional
+from itertools import chain
+
+import httpx
+
+from .... import _legacy_response
+from ...._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ...._utils import is_given, path_template, maybe_transform, strip_not_given, async_maybe_transform
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ....pagination import SyncPageCursor, AsyncPageCursor
+from ...._base_client import AsyncPaginator, make_request_options
+from ....types.beta.vaults import credential_list_params, credential_create_params, credential_update_params
+from ....types.anthropic_beta_param import AnthropicBetaParam
+from ....types.beta.vaults.beta_managed_agents_credential import BetaManagedAgentsCredential
+from ....types.beta.vaults.beta_managed_agents_deleted_credential import BetaManagedAgentsDeletedCredential
+
+__all__ = ["Credentials", "AsyncCredentials"]
+
+
+class Credentials(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> CredentialsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return CredentialsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> CredentialsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return CredentialsWithStreamingResponse(self)
+
+    def create(
+        self,
+        vault_id: str,
+        *,
+        auth: credential_create_params.Auth,
+        display_name: Optional[str] | Omit = omit,
+        metadata: Dict[str, str] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsCredential:
+        """
+        Create Credential
+
+        Args:
+          auth: Authentication details for creating a credential.
+
+          display_name: Human-readable name for the credential. Up to 255 characters.
+
+          metadata: Arbitrary key-value metadata to attach to the credential. Maximum 16 pairs, keys
+              up to 64 chars, values up to 512 chars.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not vault_id:
+            raise ValueError(f"Expected a non-empty value for `vault_id` but received {vault_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._post(
+            path_template("/v1/vaults/{vault_id}/credentials?beta=true", vault_id=vault_id),
+            body=maybe_transform(
+                {
+                    "auth": auth,
+                    "display_name": display_name,
+                    "metadata": metadata,
+                },
+                credential_create_params.CredentialCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsCredential,
+        )
+
+    def retrieve(
+        self,
+        credential_id: str,
+        *,
+        vault_id: str,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsCredential:
+        """
+        Get Credential
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not vault_id:
+            raise ValueError(f"Expected a non-empty value for `vault_id` but received {vault_id!r}")
+        if not credential_id:
+            raise ValueError(f"Expected a non-empty value for `credential_id` but received {credential_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._get(
+            path_template(
+                "/v1/vaults/{vault_id}/credentials/{credential_id}?beta=true",
+                vault_id=vault_id,
+                credential_id=credential_id,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsCredential,
+        )
+
+    def update(
+        self,
+        credential_id: str,
+        *,
+        vault_id: str,
+        auth: credential_update_params.Auth | Omit = omit,
+        display_name: Optional[str] | Omit = omit,
+        metadata: Optional[Dict[str, Optional[str]]] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsCredential:
+        """
+        Update Credential
+
+        Args:
+          auth: Updated authentication details for a credential.
+
+          display_name: Updated human-readable name for the credential. 1-255 characters.
+
+          metadata: Metadata patch. Set a key to a string to upsert it, or to null to delete it.
+              Omitted keys are preserved.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not vault_id:
+            raise ValueError(f"Expected a non-empty value for `vault_id` but received {vault_id!r}")
+        if not credential_id:
+            raise ValueError(f"Expected a non-empty value for `credential_id` but received {credential_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._post(
+            path_template(
+                "/v1/vaults/{vault_id}/credentials/{credential_id}?beta=true",
+                vault_id=vault_id,
+                credential_id=credential_id,
+            ),
+            body=maybe_transform(
+                {
+                    "auth": auth,
+                    "display_name": display_name,
+                    "metadata": metadata,
+                },
+                credential_update_params.CredentialUpdateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsCredential,
+        )
+
+    def list(
+        self,
+        vault_id: str,
+        *,
+        include_archived: bool | Omit = omit,
+        limit: int | Omit = omit,
+        page: str | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncPageCursor[BetaManagedAgentsCredential]:
+        """
+        List Credentials
+
+        Args:
+          include_archived: Whether to include archived credentials in the results.
+
+          limit: Maximum number of credentials to return per page. Defaults to 20, maximum 100.
+
+          page: Opaque pagination token from a previous `list_credentials` response.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not vault_id:
+            raise ValueError(f"Expected a non-empty value for `vault_id` but received {vault_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._get_api_list(
+            path_template("/v1/vaults/{vault_id}/credentials?beta=true", vault_id=vault_id),
+            page=SyncPageCursor[BetaManagedAgentsCredential],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "include_archived": include_archived,
+                        "limit": limit,
+                        "page": page,
+                    },
+                    credential_list_params.CredentialListParams,
+                ),
+            ),
+            model=BetaManagedAgentsCredential,
+        )
+
+    def delete(
+        self,
+        credential_id: str,
+        *,
+        vault_id: str,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsDeletedCredential:
+        """
+        Delete Credential
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not vault_id:
+            raise ValueError(f"Expected a non-empty value for `vault_id` but received {vault_id!r}")
+        if not credential_id:
+            raise ValueError(f"Expected a non-empty value for `credential_id` but received {credential_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._delete(
+            path_template(
+                "/v1/vaults/{vault_id}/credentials/{credential_id}?beta=true",
+                vault_id=vault_id,
+                credential_id=credential_id,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsDeletedCredential,
+        )
+
+    def archive(
+        self,
+        credential_id: str,
+        *,
+        vault_id: str,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsCredential:
+        """
+        Archive Credential
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not vault_id:
+            raise ValueError(f"Expected a non-empty value for `vault_id` but received {vault_id!r}")
+        if not credential_id:
+            raise ValueError(f"Expected a non-empty value for `credential_id` but received {credential_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._post(
+            path_template(
+                "/v1/vaults/{vault_id}/credentials/{credential_id}/archive?beta=true",
+                vault_id=vault_id,
+                credential_id=credential_id,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsCredential,
+        )
+
+
+class AsyncCredentials(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncCredentialsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncCredentialsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncCredentialsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return AsyncCredentialsWithStreamingResponse(self)
+
+    async def create(
+        self,
+        vault_id: str,
+        *,
+        auth: credential_create_params.Auth,
+        display_name: Optional[str] | Omit = omit,
+        metadata: Dict[str, str] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsCredential:
+        """
+        Create Credential
+
+        Args:
+          auth: Authentication details for creating a credential.
+
+          display_name: Human-readable name for the credential. Up to 255 characters.
+
+          metadata: Arbitrary key-value metadata to attach to the credential. Maximum 16 pairs, keys
+              up to 64 chars, values up to 512 chars.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not vault_id:
+            raise ValueError(f"Expected a non-empty value for `vault_id` but received {vault_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._post(
+            path_template("/v1/vaults/{vault_id}/credentials?beta=true", vault_id=vault_id),
+            body=await async_maybe_transform(
+                {
+                    "auth": auth,
+                    "display_name": display_name,
+                    "metadata": metadata,
+                },
+                credential_create_params.CredentialCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsCredential,
+        )
+
+    async def retrieve(
+        self,
+        credential_id: str,
+        *,
+        vault_id: str,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsCredential:
+        """
+        Get Credential
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not vault_id:
+            raise ValueError(f"Expected a non-empty value for `vault_id` but received {vault_id!r}")
+        if not credential_id:
+            raise ValueError(f"Expected a non-empty value for `credential_id` but received {credential_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._get(
+            path_template(
+                "/v1/vaults/{vault_id}/credentials/{credential_id}?beta=true",
+                vault_id=vault_id,
+                credential_id=credential_id,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsCredential,
+        )
+
+    async def update(
+        self,
+        credential_id: str,
+        *,
+        vault_id: str,
+        auth: credential_update_params.Auth | Omit = omit,
+        display_name: Optional[str] | Omit = omit,
+        metadata: Optional[Dict[str, Optional[str]]] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsCredential:
+        """
+        Update Credential
+
+        Args:
+          auth: Updated authentication details for a credential.
+
+          display_name: Updated human-readable name for the credential. 1-255 characters.
+
+          metadata: Metadata patch. Set a key to a string to upsert it, or to null to delete it.
+              Omitted keys are preserved.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not vault_id:
+            raise ValueError(f"Expected a non-empty value for `vault_id` but received {vault_id!r}")
+        if not credential_id:
+            raise ValueError(f"Expected a non-empty value for `credential_id` but received {credential_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._post(
+            path_template(
+                "/v1/vaults/{vault_id}/credentials/{credential_id}?beta=true",
+                vault_id=vault_id,
+                credential_id=credential_id,
+            ),
+            body=await async_maybe_transform(
+                {
+                    "auth": auth,
+                    "display_name": display_name,
+                    "metadata": metadata,
+                },
+                credential_update_params.CredentialUpdateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsCredential,
+        )
+
+    def list(
+        self,
+        vault_id: str,
+        *,
+        include_archived: bool | Omit = omit,
+        limit: int | Omit = omit,
+        page: str | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[BetaManagedAgentsCredential, AsyncPageCursor[BetaManagedAgentsCredential]]:
+        """
+        List Credentials
+
+        Args:
+          include_archived: Whether to include archived credentials in the results.
+
+          limit: Maximum number of credentials to return per page. Defaults to 20, maximum 100.
+
+          page: Opaque pagination token from a previous `list_credentials` response.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not vault_id:
+            raise ValueError(f"Expected a non-empty value for `vault_id` but received {vault_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._get_api_list(
+            path_template("/v1/vaults/{vault_id}/credentials?beta=true", vault_id=vault_id),
+            page=AsyncPageCursor[BetaManagedAgentsCredential],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "include_archived": include_archived,
+                        "limit": limit,
+                        "page": page,
+                    },
+                    credential_list_params.CredentialListParams,
+                ),
+            ),
+            model=BetaManagedAgentsCredential,
+        )
+
+    async def delete(
+        self,
+        credential_id: str,
+        *,
+        vault_id: str,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsDeletedCredential:
+        """
+        Delete Credential
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not vault_id:
+            raise ValueError(f"Expected a non-empty value for `vault_id` but received {vault_id!r}")
+        if not credential_id:
+            raise ValueError(f"Expected a non-empty value for `credential_id` but received {credential_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._delete(
+            path_template(
+                "/v1/vaults/{vault_id}/credentials/{credential_id}?beta=true",
+                vault_id=vault_id,
+                credential_id=credential_id,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsDeletedCredential,
+        )
+
+    async def archive(
+        self,
+        credential_id: str,
+        *,
+        vault_id: str,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsCredential:
+        """
+        Archive Credential
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not vault_id:
+            raise ValueError(f"Expected a non-empty value for `vault_id` but received {vault_id!r}")
+        if not credential_id:
+            raise ValueError(f"Expected a non-empty value for `credential_id` but received {credential_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._post(
+            path_template(
+                "/v1/vaults/{vault_id}/credentials/{credential_id}/archive?beta=true",
+                vault_id=vault_id,
+                credential_id=credential_id,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsCredential,
+        )
+
+
+class CredentialsWithRawResponse:
+    def __init__(self, credentials: Credentials) -> None:
+        self._credentials = credentials
+
+        self.create = _legacy_response.to_raw_response_wrapper(
+            credentials.create,
+        )
+        self.retrieve = _legacy_response.to_raw_response_wrapper(
+            credentials.retrieve,
+        )
+        self.update = _legacy_response.to_raw_response_wrapper(
+            credentials.update,
+        )
+        self.list = _legacy_response.to_raw_response_wrapper(
+            credentials.list,
+        )
+        self.delete = _legacy_response.to_raw_response_wrapper(
+            credentials.delete,
+        )
+        self.archive = _legacy_response.to_raw_response_wrapper(
+            credentials.archive,
+        )
+
+
+class AsyncCredentialsWithRawResponse:
+    def __init__(self, credentials: AsyncCredentials) -> None:
+        self._credentials = credentials
+
+        self.create = _legacy_response.async_to_raw_response_wrapper(
+            credentials.create,
+        )
+        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
+            credentials.retrieve,
+        )
+        self.update = _legacy_response.async_to_raw_response_wrapper(
+            credentials.update,
+        )
+        self.list = _legacy_response.async_to_raw_response_wrapper(
+            credentials.list,
+        )
+        self.delete = _legacy_response.async_to_raw_response_wrapper(
+            credentials.delete,
+        )
+        self.archive = _legacy_response.async_to_raw_response_wrapper(
+            credentials.archive,
+        )
+
+
+class CredentialsWithStreamingResponse:
+    def __init__(self, credentials: Credentials) -> None:
+        self._credentials = credentials
+
+        self.create = to_streamed_response_wrapper(
+            credentials.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            credentials.retrieve,
+        )
+        self.update = to_streamed_response_wrapper(
+            credentials.update,
+        )
+        self.list = to_streamed_response_wrapper(
+            credentials.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            credentials.delete,
+        )
+        self.archive = to_streamed_response_wrapper(
+            credentials.archive,
+        )
+
+
+class AsyncCredentialsWithStreamingResponse:
+    def __init__(self, credentials: AsyncCredentials) -> None:
+        self._credentials = credentials
+
+        self.create = async_to_streamed_response_wrapper(
+            credentials.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            credentials.retrieve,
+        )
+        self.update = async_to_streamed_response_wrapper(
+            credentials.update,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            credentials.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            credentials.delete,
+        )
+        self.archive = async_to_streamed_response_wrapper(
+            credentials.archive,
+        )

venv/lib/python3.12/site-packages/anthropic/resources/beta/vaults/vaults.py

@@ -0,0 +1,847 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, List, Optional
+from itertools import chain
+
+import httpx
+
+from .... import _legacy_response
+from ...._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ...._utils import is_given, path_template, maybe_transform, strip_not_given, async_maybe_transform
+from ...._compat import cached_property
+from .credentials import (
+    Credentials,
+    AsyncCredentials,
+    CredentialsWithRawResponse,
+    AsyncCredentialsWithRawResponse,
+    CredentialsWithStreamingResponse,
+    AsyncCredentialsWithStreamingResponse,
+)
+from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ....pagination import SyncPageCursor, AsyncPageCursor
+from ....types.beta import vault_list_params, vault_create_params, vault_update_params
+from ...._base_client import AsyncPaginator, make_request_options
+from ....types.anthropic_beta_param import AnthropicBetaParam
+from ....types.beta.beta_managed_agents_vault import BetaManagedAgentsVault
+from ....types.beta.beta_managed_agents_deleted_vault import BetaManagedAgentsDeletedVault
+
+__all__ = ["Vaults", "AsyncVaults"]
+
+
+class Vaults(SyncAPIResource):
+    @cached_property
+    def credentials(self) -> Credentials:
+        return Credentials(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> VaultsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return VaultsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> VaultsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return VaultsWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        display_name: str,
+        metadata: Dict[str, str] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsVault:
+        """Create Vault
+
+        Args:
+          display_name: Human-readable name for the vault.
+
+        1-255 characters.
+
+          metadata: Arbitrary key-value metadata to attach to the vault. Maximum 16 pairs, keys up
+              to 64 chars, values up to 512 chars.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._post(
+            "/v1/vaults?beta=true",
+            body=maybe_transform(
+                {
+                    "display_name": display_name,
+                    "metadata": metadata,
+                },
+                vault_create_params.VaultCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsVault,
+        )
+
+    def retrieve(
+        self,
+        vault_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsVault:
+        """
+        Get Vault
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not vault_id:
+            raise ValueError(f"Expected a non-empty value for `vault_id` but received {vault_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._get(
+            path_template("/v1/vaults/{vault_id}?beta=true", vault_id=vault_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsVault,
+        )
+
+    def update(
+        self,
+        vault_id: str,
+        *,
+        display_name: Optional[str] | Omit = omit,
+        metadata: Optional[Dict[str, Optional[str]]] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsVault:
+        """Update Vault
+
+        Args:
+          display_name: Updated human-readable name for the vault.
+
+        1-255 characters.
+
+          metadata: Metadata patch. Set a key to a string to upsert it, or to null to delete it.
+              Omitted keys are preserved.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not vault_id:
+            raise ValueError(f"Expected a non-empty value for `vault_id` but received {vault_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._post(
+            path_template("/v1/vaults/{vault_id}?beta=true", vault_id=vault_id),
+            body=maybe_transform(
+                {
+                    "display_name": display_name,
+                    "metadata": metadata,
+                },
+                vault_update_params.VaultUpdateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsVault,
+        )
+
+    def list(
+        self,
+        *,
+        include_archived: bool | Omit = omit,
+        limit: int | Omit = omit,
+        page: str | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncPageCursor[BetaManagedAgentsVault]:
+        """
+        List Vaults
+
+        Args:
+          include_archived: Whether to include archived vaults in the results.
+
+          limit: Maximum number of vaults to return per page. Defaults to 20, maximum 100.
+
+          page: Opaque pagination token from a previous `list_vaults` response.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._get_api_list(
+            "/v1/vaults?beta=true",
+            page=SyncPageCursor[BetaManagedAgentsVault],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "include_archived": include_archived,
+                        "limit": limit,
+                        "page": page,
+                    },
+                    vault_list_params.VaultListParams,
+                ),
+            ),
+            model=BetaManagedAgentsVault,
+        )
+
+    def delete(
+        self,
+        vault_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsDeletedVault:
+        """
+        Delete Vault
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not vault_id:
+            raise ValueError(f"Expected a non-empty value for `vault_id` but received {vault_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._delete(
+            path_template("/v1/vaults/{vault_id}?beta=true", vault_id=vault_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsDeletedVault,
+        )
+
+    def archive(
+        self,
+        vault_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsVault:
+        """
+        Archive Vault
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not vault_id:
+            raise ValueError(f"Expected a non-empty value for `vault_id` but received {vault_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._post(
+            path_template("/v1/vaults/{vault_id}/archive?beta=true", vault_id=vault_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsVault,
+        )
+
+
+class AsyncVaults(AsyncAPIResource):
+    @cached_property
+    def credentials(self) -> AsyncCredentials:
+        return AsyncCredentials(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncVaultsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncVaultsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncVaultsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anthropics/anthropic-sdk-python#with_streaming_response
+        """
+        return AsyncVaultsWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        display_name: str,
+        metadata: Dict[str, str] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsVault:
+        """Create Vault
+
+        Args:
+          display_name: Human-readable name for the vault.
+
+        1-255 characters.
+
+          metadata: Arbitrary key-value metadata to attach to the vault. Maximum 16 pairs, keys up
+              to 64 chars, values up to 512 chars.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._post(
+            "/v1/vaults?beta=true",
+            body=await async_maybe_transform(
+                {
+                    "display_name": display_name,
+                    "metadata": metadata,
+                },
+                vault_create_params.VaultCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsVault,
+        )
+
+    async def retrieve(
+        self,
+        vault_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsVault:
+        """
+        Get Vault
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not vault_id:
+            raise ValueError(f"Expected a non-empty value for `vault_id` but received {vault_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._get(
+            path_template("/v1/vaults/{vault_id}?beta=true", vault_id=vault_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsVault,
+        )
+
+    async def update(
+        self,
+        vault_id: str,
+        *,
+        display_name: Optional[str] | Omit = omit,
+        metadata: Optional[Dict[str, Optional[str]]] | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsVault:
+        """Update Vault
+
+        Args:
+          display_name: Updated human-readable name for the vault.
+
+        1-255 characters.
+
+          metadata: Metadata patch. Set a key to a string to upsert it, or to null to delete it.
+              Omitted keys are preserved.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not vault_id:
+            raise ValueError(f"Expected a non-empty value for `vault_id` but received {vault_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._post(
+            path_template("/v1/vaults/{vault_id}?beta=true", vault_id=vault_id),
+            body=await async_maybe_transform(
+                {
+                    "display_name": display_name,
+                    "metadata": metadata,
+                },
+                vault_update_params.VaultUpdateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsVault,
+        )
+
+    def list(
+        self,
+        *,
+        include_archived: bool | Omit = omit,
+        limit: int | Omit = omit,
+        page: str | Omit = omit,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[BetaManagedAgentsVault, AsyncPageCursor[BetaManagedAgentsVault]]:
+        """
+        List Vaults
+
+        Args:
+          include_archived: Whether to include archived vaults in the results.
+
+          limit: Maximum number of vaults to return per page. Defaults to 20, maximum 100.
+
+          page: Opaque pagination token from a previous `list_vaults` response.
+
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return self._get_api_list(
+            "/v1/vaults?beta=true",
+            page=AsyncPageCursor[BetaManagedAgentsVault],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "include_archived": include_archived,
+                        "limit": limit,
+                        "page": page,
+                    },
+                    vault_list_params.VaultListParams,
+                ),
+            ),
+            model=BetaManagedAgentsVault,
+        )
+
+    async def delete(
+        self,
+        vault_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsDeletedVault:
+        """
+        Delete Vault
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not vault_id:
+            raise ValueError(f"Expected a non-empty value for `vault_id` but received {vault_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._delete(
+            path_template("/v1/vaults/{vault_id}?beta=true", vault_id=vault_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsDeletedVault,
+        )
+
+    async def archive(
+        self,
+        vault_id: str,
+        *,
+        betas: List[AnthropicBetaParam] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BetaManagedAgentsVault:
+        """
+        Archive Vault
+
+        Args:
+          betas: Optional header to specify the beta version(s) you want to use.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not vault_id:
+            raise ValueError(f"Expected a non-empty value for `vault_id` but received {vault_id!r}")
+        extra_headers = {
+            **strip_not_given(
+                {
+                    "anthropic-beta": ",".join(chain((str(e) for e in betas), ["managed-agents-2026-04-01"]))
+                    if is_given(betas)
+                    else not_given
+                }
+            ),
+            **(extra_headers or {}),
+        }
+        extra_headers = {"anthropic-beta": "managed-agents-2026-04-01", **(extra_headers or {})}
+        return await self._post(
+            path_template("/v1/vaults/{vault_id}/archive?beta=true", vault_id=vault_id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BetaManagedAgentsVault,
+        )
+
+
+class VaultsWithRawResponse:
+    def __init__(self, vaults: Vaults) -> None:
+        self._vaults = vaults
+
+        self.create = _legacy_response.to_raw_response_wrapper(
+            vaults.create,
+        )
+        self.retrieve = _legacy_response.to_raw_response_wrapper(
+            vaults.retrieve,
+        )
+        self.update = _legacy_response.to_raw_response_wrapper(
+            vaults.update,
+        )
+        self.list = _legacy_response.to_raw_response_wrapper(
+            vaults.list,
+        )
+        self.delete = _legacy_response.to_raw_response_wrapper(
+            vaults.delete,
+        )
+        self.archive = _legacy_response.to_raw_response_wrapper(
+            vaults.archive,
+        )
+
+    @cached_property
+    def credentials(self) -> CredentialsWithRawResponse:
+        return CredentialsWithRawResponse(self._vaults.credentials)
+
+
+class AsyncVaultsWithRawResponse:
+    def __init__(self, vaults: AsyncVaults) -> None:
+        self._vaults = vaults
+
+        self.create = _legacy_response.async_to_raw_response_wrapper(
+            vaults.create,
+        )
+        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
+            vaults.retrieve,
+        )
+        self.update = _legacy_response.async_to_raw_response_wrapper(
+            vaults.update,
+        )
+        self.list = _legacy_response.async_to_raw_response_wrapper(
+            vaults.list,
+        )
+        self.delete = _legacy_response.async_to_raw_response_wrapper(
+            vaults.delete,
+        )
+        self.archive = _legacy_response.async_to_raw_response_wrapper(
+            vaults.archive,
+        )
+
+    @cached_property
+    def credentials(self) -> AsyncCredentialsWithRawResponse:
+        return AsyncCredentialsWithRawResponse(self._vaults.credentials)
+
+
+class VaultsWithStreamingResponse:
+    def __init__(self, vaults: Vaults) -> None:
+        self._vaults = vaults
+
+        self.create = to_streamed_response_wrapper(
+            vaults.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            vaults.retrieve,
+        )
+        self.update = to_streamed_response_wrapper(
+            vaults.update,
+        )
+        self.list = to_streamed_response_wrapper(
+            vaults.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            vaults.delete,
+        )
+        self.archive = to_streamed_response_wrapper(
+            vaults.archive,
+        )
+
+    @cached_property
+    def credentials(self) -> CredentialsWithStreamingResponse:
+        return CredentialsWithStreamingResponse(self._vaults.credentials)
+
+
+class AsyncVaultsWithStreamingResponse:
+    def __init__(self, vaults: AsyncVaults) -> None:
+        self._vaults = vaults
+
+        self.create = async_to_streamed_response_wrapper(
+            vaults.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            vaults.retrieve,
+        )
+        self.update = async_to_streamed_response_wrapper(
+            vaults.update,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            vaults.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            vaults.delete,
+        )
+        self.archive = async_to_streamed_response_wrapper(
+            vaults.archive,
+        )
+
+    @cached_property
+    def credentials(self) -> AsyncCredentialsWithStreamingResponse:
+        return AsyncCredentialsWithStreamingResponse(self._vaults.credentials)