diff --git a/.release-please-manifest.json b/.release-please-manifest.json
index d486cde7..ca93fdaa 100644
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1,3 +1,3 @@
{
- ".": "0.96.0"
+ ".": "0.97.0"
}
\ No newline at end of file
diff --git a/.stats.yml b/.stats.yml
index d44995ad..129aa034 100644
--- a/.stats.yml
+++ b/.stats.yml
@@ -1,4 +1,4 @@
-configured_endpoints: 77
-openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/anthropic%2Fanthropic-e0696f59ae07dc1a9c5a8fc87a4eb05eb35afabaac0b5ff0ea38810fa9dd4a74.yml
-openapi_spec_hash: 69278ebbb0d1aa0b322bbbd5128bcec5
-config_hash: b0dbd234c2752507397c139a416f6cba
+configured_endpoints: 91
+openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/anthropic%2Fanthropic-6811827071199207cf69c4e64cae1b41e7e74cdb14048e9c748701e474c694a7.yml
+openapi_spec_hash: 0feddcbb70c1d373b305f9c95f7df8e6
+config_hash: c7cdab4e4eb2befb0d99f6db5c3d4737
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 827c6774..8ed12792 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,31 @@
# Changelog
+## 0.97.0 (2026-04-23)
+
+Full Changelog: [v0.96.0...v0.97.0](https://github.com/anthropics/anthropic-sdk-python/compare/v0.96.0...v0.97.0)
+
+### Features
+
+* **api:** CMA Memory public beta ([fc30ebe](https://github.com/anthropics/anthropic-sdk-python/commit/fc30ebe5ca81204faa0b1d756b61dad176e37dcb))
+
+
+### Bug Fixes
+
+* **api:** fix errors in api spec ([f946de8](https://github.com/anthropics/anthropic-sdk-python/commit/f946de8da00748b472489e93ab4920d64d1cb22d))
+* **api:** restore missing features ([72212ab](https://github.com/anthropics/anthropic-sdk-python/commit/72212ab8408af389981e9e6b111c00460b2b17e4))
+
+
+### Performance Improvements
+
+* **client:** optimize file structure copying in multipart requests ([1f9eed3](https://github.com/anthropics/anthropic-sdk-python/commit/1f9eed3a953c8cef0967df8470e04f7ac8fe3235))
+
+
+### Chores
+
+* add missing import ([4b12f5e](https://github.com/anthropics/anthropic-sdk-python/commit/4b12f5e0f4c29a234cd05f93c603b9cae2011aaa))
+* **internal:** more robust bootstrap script ([7ed7370](https://github.com/anthropics/anthropic-sdk-python/commit/7ed737089d1f28385ee827f601ba81f1935d0b6a))
+* **tests:** bump steady to v0.22.1 ([a4b7184](https://github.com/anthropics/anthropic-sdk-python/commit/a4b7184e57410ae92a409db5ee6fec90edceaa51))
+
## 0.96.0 (2026-04-16)
Full Changelog: [v0.95.0...v0.96.0](https://github.com/anthropics/anthropic-sdk-python/compare/v0.95.0...v0.96.0)
diff --git a/api.md b/api.md
index 0ec12114..a5cd0e64 100644
--- a/api.md
+++ b/api.md
@@ -628,6 +628,7 @@ from anthropic.types.beta import (
BetaManagedAgentsDeletedSession,
BetaManagedAgentsFileResourceParams,
BetaManagedAgentsGitHubRepositoryResourceParams,
+ BetaManagedAgentsMemoryStoreResourceParam,
BetaManagedAgentsSession,
BetaManagedAgentsSessionAgent,
BetaManagedAgentsSessionStats,
@@ -720,6 +721,7 @@ from anthropic.types.beta.sessions import (
BetaManagedAgentsDeleteSessionResource,
BetaManagedAgentsFileResource,
BetaManagedAgentsGitHubRepositoryResource,
+ BetaManagedAgentsMemoryStoreResource,
BetaManagedAgentsSessionResource,
ResourceRetrieveResponse,
ResourceUpdateResponse,
@@ -788,6 +790,72 @@ Methods:
- client.beta.vaults.credentials.delete(credential_id, \*, vault_id) -> BetaManagedAgentsDeletedCredential
- client.beta.vaults.credentials.archive(credential_id, \*, vault_id) -> BetaManagedAgentsCredential
+## MemoryStores
+
+Types:
+
+```python
+from anthropic.types.beta import BetaManagedAgentsDeletedMemoryStore, BetaManagedAgentsMemoryStore
+```
+
+Methods:
+
+- client.beta.memory_stores.create(\*\*params) -> BetaManagedAgentsMemoryStore
+- client.beta.memory_stores.retrieve(memory_store_id) -> BetaManagedAgentsMemoryStore
+- client.beta.memory_stores.update(memory_store_id, \*\*params) -> BetaManagedAgentsMemoryStore
+- client.beta.memory_stores.list(\*\*params) -> SyncPageCursor[BetaManagedAgentsMemoryStore]
+- client.beta.memory_stores.delete(memory_store_id) -> BetaManagedAgentsDeletedMemoryStore
+- client.beta.memory_stores.archive(memory_store_id) -> BetaManagedAgentsMemoryStore
+
+### Memories
+
+Types:
+
+```python
+from anthropic.types.beta.memory_stores import (
+ BetaManagedAgentsConflictError,
+ BetaManagedAgentsContentSha256Precondition,
+ BetaManagedAgentsDeletedMemory,
+ BetaManagedAgentsError,
+ BetaManagedAgentsMemory,
+ BetaManagedAgentsMemoryListItem,
+ BetaManagedAgentsMemoryPathConflictError,
+ BetaManagedAgentsMemoryPreconditionFailedError,
+ BetaManagedAgentsMemoryPrefix,
+ BetaManagedAgentsMemoryView,
+ BetaManagedAgentsPrecondition,
+)
+```
+
+Methods:
+
+- client.beta.memory_stores.memories.create(memory_store_id, \*\*params) -> BetaManagedAgentsMemory
+- client.beta.memory_stores.memories.retrieve(memory_id, \*, memory_store_id, \*\*params) -> BetaManagedAgentsMemory
+- client.beta.memory_stores.memories.update(memory_id, \*, memory_store_id, \*\*params) -> BetaManagedAgentsMemory
+- client.beta.memory_stores.memories.list(memory_store_id, \*\*params) -> SyncPageCursor[BetaManagedAgentsMemoryListItem]
+- client.beta.memory_stores.memories.delete(memory_id, \*, memory_store_id, \*\*params) -> BetaManagedAgentsDeletedMemory
+
+### MemoryVersions
+
+Types:
+
+```python
+from anthropic.types.beta.memory_stores import (
+ BetaManagedAgentsActor,
+ BetaManagedAgentsAPIActor,
+ BetaManagedAgentsMemoryVersion,
+ BetaManagedAgentsMemoryVersionOperation,
+ BetaManagedAgentsSessionActor,
+ BetaManagedAgentsUserActor,
+)
+```
+
+Methods:
+
+- client.beta.memory_stores.memory_versions.retrieve(memory_version_id, \*, memory_store_id, \*\*params) -> BetaManagedAgentsMemoryVersion
+- client.beta.memory_stores.memory_versions.list(memory_store_id, \*\*params) -> SyncPageCursor[BetaManagedAgentsMemoryVersion]
+- client.beta.memory_stores.memory_versions.redact(memory_version_id, \*, memory_store_id) -> BetaManagedAgentsMemoryVersion
+
## Files
Types:
diff --git a/pyproject.toml b/pyproject.toml
index 544ae501..ffe7b8f5 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
[project]
name = "anthropic"
-version = "0.96.0"
+version = "0.97.0"
description = "The official Python library for the anthropic API"
dynamic = ["readme"]
license = "MIT"
diff --git a/scripts/bootstrap b/scripts/bootstrap
index 4638ec69..5a23841b 100755
--- a/scripts/bootstrap
+++ b/scripts/bootstrap
@@ -4,7 +4,7 @@ set -e
cd "$(dirname "$0")/.."
-if [ -f "Brewfile" ] && [ "$(uname -s)" = "Darwin" ] && [ "$SKIP_BREW" != "1" ] && [ -t 0 ]; then
+if [ -f "Brewfile" ] && [ "$(uname -s)" = "Darwin" ] && [ "${SKIP_BREW:-}" != "1" ] && [ -t 0 ]; then
brew bundle check >/dev/null 2>&1 || {
echo -n "==> Install Homebrew dependencies? (y/N): "
read -r response
diff --git a/scripts/mock b/scripts/mock
index 1f84b12f..2147c2f8 100755
--- a/scripts/mock
+++ b/scripts/mock
@@ -22,9 +22,9 @@ echo "==> Starting mock server with URL ${URL}"
# Run steady mock on the given spec
if [ "$1" == "--daemon" ]; then
# Pre-install the package so the download doesn't eat into the startup timeout
- npm exec --package=@stdy/cli@0.20.2 -- steady --version
+ npm exec --package=@stdy/cli@0.22.1 -- steady --version
- npm exec --package=@stdy/cli@0.20.2 -- steady --host 127.0.0.1 -p 4010 --validator-query-array-format=comma --validator-form-array-format=brackets --validator-query-object-format=brackets --validator-form-object-format=brackets "$URL" &> .stdy.log &
+ npm exec --package=@stdy/cli@0.22.1 -- steady --host 127.0.0.1 -p 4010 --validator-query-array-format=comma --validator-form-array-format=brackets --validator-query-object-format=brackets --validator-form-object-format=brackets "$URL" &> .stdy.log &
# Wait for server to come online via health endpoint (max 30s)
echo -n "Waiting for server"
@@ -48,5 +48,5 @@ if [ "$1" == "--daemon" ]; then
echo
else
- npm exec --package=@stdy/cli@0.20.2 -- steady --host 127.0.0.1 -p 4010 --validator-query-array-format=comma --validator-form-array-format=brackets --validator-query-object-format=brackets --validator-form-object-format=brackets "$URL"
+ npm exec --package=@stdy/cli@0.22.1 -- steady --host 127.0.0.1 -p 4010 --validator-query-array-format=comma --validator-form-array-format=brackets --validator-query-object-format=brackets --validator-form-object-format=brackets "$URL"
fi
diff --git a/scripts/test b/scripts/test
index 03fce0b9..6547bc04 100755
--- a/scripts/test
+++ b/scripts/test
@@ -43,7 +43,7 @@ elif ! steady_is_running ; then
echo -e "To run the server, pass in the path or url of your OpenAPI"
echo -e "spec to the steady command:"
echo
- echo -e " \$ ${YELLOW}npm exec --package=@stdy/cli@0.20.2 -- steady path/to/your.openapi.yml --host 127.0.0.1 -p 4010 --validator-query-array-format=comma --validator-form-array-format=brackets --validator-query-object-format=brackets --validator-form-object-format=brackets${NC}"
+ echo -e " \$ ${YELLOW}npm exec --package=@stdy/cli@0.22.1 -- steady path/to/your.openapi.yml --host 127.0.0.1 -p 4010 --validator-query-array-format=comma --validator-form-array-format=brackets --validator-query-object-format=brackets --validator-form-object-format=brackets${NC}"
echo
exit 1
diff --git a/src/anthropic/_files.py b/src/anthropic/_files.py
index f2a6f94e..4c74556c 100644
--- a/src/anthropic/_files.py
+++ b/src/anthropic/_files.py
@@ -3,8 +3,8 @@
import io
import os
import pathlib
-from typing import overload
-from typing_extensions import TypeGuard
+from typing import Sequence, cast, overload
+from typing_extensions import TypeVar, TypeGuard
import anyio
@@ -17,7 +17,9 @@
HttpxFileContent,
HttpxRequestFiles,
)
-from ._utils import is_tuple_t, is_mapping_t, is_sequence_t
+from ._utils import is_list, is_mapping, is_tuple_t, is_mapping_t, is_sequence_t
+
+_T = TypeVar("_T")
def is_base64_file_input(obj: object) -> TypeGuard[Base64FileInput]:
@@ -121,3 +123,51 @@ async def async_read_file_content(file: FileContent) -> HttpxFileContent:
return await anyio.Path(file).read_bytes()
return file
+
+
+def deepcopy_with_paths(item: _T, paths: Sequence[Sequence[str]]) -> _T:
+ """Copy only the containers along the given paths.
+
+ Used to guard against mutation by extract_files without copying the entire structure.
+ Only dicts and lists that lie on a path are copied; everything else
+ is returned by reference.
+
+ For example, given paths=[["foo", "files", "file"]] and the structure:
+ {
+ "foo": {
+ "bar": {"baz": {}},
+ "files": {"file": }
+ }
+ }
+ The root dict, "foo", and "files" are copied (they lie on the path).
+ "bar" and "baz" are returned by reference (off the path).
+ """
+ return _deepcopy_with_paths(item, paths, 0)
+
+
+def _deepcopy_with_paths(item: _T, paths: Sequence[Sequence[str]], index: int) -> _T:
+ if not paths:
+ return item
+ if is_mapping(item):
+ key_to_paths: dict[str, list[Sequence[str]]] = {}
+ for path in paths:
+ if index < len(path):
+ key_to_paths.setdefault(path[index], []).append(path)
+
+ # if no path continues through this mapping, it won't be mutated and copying it is redundant
+ if not key_to_paths:
+ return item
+
+ result = dict(item)
+ for key, subpaths in key_to_paths.items():
+ if key in result:
+ result[key] = _deepcopy_with_paths(result[key], subpaths, index + 1)
+ return cast(_T, result)
+ if is_list(item):
+ array_paths = [path for path in paths if index < len(path) and path[index] == ""]
+
+ # if no path expects a list here, nothing will be mutated inside it - return by reference
+ if not array_paths:
+ return cast(_T, item)
+ return cast(_T, [_deepcopy_with_paths(entry, array_paths, index + 1) for entry in item])
+ return item
diff --git a/src/anthropic/_utils/__init__.py b/src/anthropic/_utils/__init__.py
index 913f7e4e..420d5b67 100644
--- a/src/anthropic/_utils/__init__.py
+++ b/src/anthropic/_utils/__init__.py
@@ -24,7 +24,6 @@
coerce_integer as coerce_integer,
file_from_path as file_from_path,
strip_not_given as strip_not_given,
- deepcopy_minimal as deepcopy_minimal,
get_async_library as get_async_library,
maybe_coerce_float as maybe_coerce_float,
get_required_header as get_required_header,
diff --git a/src/anthropic/_utils/_utils.py b/src/anthropic/_utils/_utils.py
index 63b8cd60..771859f5 100644
--- a/src/anthropic/_utils/_utils.py
+++ b/src/anthropic/_utils/_utils.py
@@ -177,21 +177,6 @@ def is_iterable(obj: object) -> TypeGuard[Iterable[object]]:
return isinstance(obj, Iterable)
-def deepcopy_minimal(item: _T) -> _T:
- """Minimal reimplementation of copy.deepcopy() that will only copy certain object types:
-
- - mappings, e.g. `dict`
- - list
-
- This is done for performance reasons.
- """
- if is_mapping(item):
- return cast(_T, {k: deepcopy_minimal(v) for k, v in item.items()})
- if is_list(item):
- return cast(_T, [deepcopy_minimal(entry) for entry in item])
- return item
-
-
# copied from https://github.com/Rapptz/RoboDanny
def human_join(seq: Sequence[str], *, delim: str = ", ", final: str = "or") -> str:
size = len(seq)
diff --git a/src/anthropic/_version.py b/src/anthropic/_version.py
index a820f00f..92734611 100644
--- a/src/anthropic/_version.py
+++ b/src/anthropic/_version.py
@@ -1,4 +1,4 @@
# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
__title__ = "anthropic"
-__version__ = "0.96.0" # x-release-please-version
+__version__ = "0.97.0" # x-release-please-version
diff --git a/src/anthropic/resources/beta/__init__.py b/src/anthropic/resources/beta/__init__.py
index e0fab122..9c74f2e5 100644
--- a/src/anthropic/resources/beta/__init__.py
+++ b/src/anthropic/resources/beta/__init__.py
@@ -72,6 +72,14 @@
EnvironmentsWithStreamingResponse,
AsyncEnvironmentsWithStreamingResponse,
)
+from .memory_stores import (
+ MemoryStores,
+ AsyncMemoryStores,
+ MemoryStoresWithRawResponse,
+ AsyncMemoryStoresWithRawResponse,
+ MemoryStoresWithStreamingResponse,
+ AsyncMemoryStoresWithStreamingResponse,
+)
from .user_profiles import (
UserProfiles,
AsyncUserProfiles,
@@ -118,6 +126,12 @@
"AsyncVaultsWithRawResponse",
"VaultsWithStreamingResponse",
"AsyncVaultsWithStreamingResponse",
+ "MemoryStores",
+ "AsyncMemoryStores",
+ "MemoryStoresWithRawResponse",
+ "AsyncMemoryStoresWithRawResponse",
+ "MemoryStoresWithStreamingResponse",
+ "AsyncMemoryStoresWithStreamingResponse",
"Files",
"AsyncFiles",
"FilesWithRawResponse",
diff --git a/src/anthropic/resources/beta/beta.py b/src/anthropic/resources/beta/beta.py
index 9a60f19a..a0ef6387 100644
--- a/src/anthropic/resources/beta/beta.py
+++ b/src/anthropic/resources/beta/beta.py
@@ -76,6 +76,14 @@
SessionsWithStreamingResponse,
AsyncSessionsWithStreamingResponse,
)
+from .memory_stores.memory_stores import (
+ MemoryStores,
+ AsyncMemoryStores,
+ MemoryStoresWithRawResponse,
+ AsyncMemoryStoresWithRawResponse,
+ MemoryStoresWithStreamingResponse,
+ AsyncMemoryStoresWithStreamingResponse,
+)
__all__ = ["Beta", "AsyncBeta"]
@@ -105,6 +113,10 @@ def sessions(self) -> Sessions:
def vaults(self) -> Vaults:
return Vaults(self._client)
+ @cached_property
+ def memory_stores(self) -> MemoryStores:
+ return MemoryStores(self._client)
+
@cached_property
def files(self) -> Files:
return Files(self._client)
@@ -162,6 +174,10 @@ def sessions(self) -> AsyncSessions:
def vaults(self) -> AsyncVaults:
return AsyncVaults(self._client)
+ @cached_property
+ def memory_stores(self) -> AsyncMemoryStores:
+ return AsyncMemoryStores(self._client)
+
@cached_property
def files(self) -> AsyncFiles:
return AsyncFiles(self._client)
@@ -222,6 +238,10 @@ def sessions(self) -> SessionsWithRawResponse:
def vaults(self) -> VaultsWithRawResponse:
return VaultsWithRawResponse(self._beta.vaults)
+ @cached_property
+ def memory_stores(self) -> MemoryStoresWithRawResponse:
+ return MemoryStoresWithRawResponse(self._beta.memory_stores)
+
@cached_property
def files(self) -> FilesWithRawResponse:
return FilesWithRawResponse(self._beta.files)
@@ -263,6 +283,10 @@ def sessions(self) -> AsyncSessionsWithRawResponse:
def vaults(self) -> AsyncVaultsWithRawResponse:
return AsyncVaultsWithRawResponse(self._beta.vaults)
+ @cached_property
+ def memory_stores(self) -> AsyncMemoryStoresWithRawResponse:
+ return AsyncMemoryStoresWithRawResponse(self._beta.memory_stores)
+
@cached_property
def files(self) -> AsyncFilesWithRawResponse:
return AsyncFilesWithRawResponse(self._beta.files)
@@ -304,6 +328,10 @@ def sessions(self) -> SessionsWithStreamingResponse:
def vaults(self) -> VaultsWithStreamingResponse:
return VaultsWithStreamingResponse(self._beta.vaults)
+ @cached_property
+ def memory_stores(self) -> MemoryStoresWithStreamingResponse:
+ return MemoryStoresWithStreamingResponse(self._beta.memory_stores)
+
@cached_property
def files(self) -> FilesWithStreamingResponse:
return FilesWithStreamingResponse(self._beta.files)
@@ -345,6 +373,10 @@ def sessions(self) -> AsyncSessionsWithStreamingResponse:
def vaults(self) -> AsyncVaultsWithStreamingResponse:
return AsyncVaultsWithStreamingResponse(self._beta.vaults)
+ @cached_property
+ def memory_stores(self) -> AsyncMemoryStoresWithStreamingResponse:
+ return AsyncMemoryStoresWithStreamingResponse(self._beta.memory_stores)
+
@cached_property
def files(self) -> AsyncFilesWithStreamingResponse:
return AsyncFilesWithStreamingResponse(self._beta.files)
diff --git a/src/anthropic/resources/beta/files.py b/src/anthropic/resources/beta/files.py
index e5fd29e3..0bc03801 100644
--- a/src/anthropic/resources/beta/files.py
+++ b/src/anthropic/resources/beta/files.py
@@ -8,16 +8,9 @@
import httpx
from ... import _legacy_response
+from ..._files import deepcopy_with_paths
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 ..._utils import is_given, extract_files, path_template, maybe_transform, strip_not_given, async_maybe_transform
from ..._compat import cached_property
from ..._resource import SyncAPIResource, AsyncAPIResource
from ..._response import (
@@ -326,7 +319,7 @@ def upload(
}
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})
+ body = deepcopy_with_paths({"file": 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.
@@ -626,7 +619,7 @@ async def upload(
}
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})
+ body = deepcopy_with_paths({"file": 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.
diff --git a/src/anthropic/resources/beta/memory_stores/__init__.py b/src/anthropic/resources/beta/memory_stores/__init__.py
new file mode 100644
index 00000000..497fbfab
--- /dev/null
+++ b/src/anthropic/resources/beta/memory_stores/__init__.py
@@ -0,0 +1,47 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .memories import (
+ Memories,
+ AsyncMemories,
+ MemoriesWithRawResponse,
+ AsyncMemoriesWithRawResponse,
+ MemoriesWithStreamingResponse,
+ AsyncMemoriesWithStreamingResponse,
+)
+from .memory_stores import (
+ MemoryStores,
+ AsyncMemoryStores,
+ MemoryStoresWithRawResponse,
+ AsyncMemoryStoresWithRawResponse,
+ MemoryStoresWithStreamingResponse,
+ AsyncMemoryStoresWithStreamingResponse,
+)
+from .memory_versions import (
+ MemoryVersions,
+ AsyncMemoryVersions,
+ MemoryVersionsWithRawResponse,
+ AsyncMemoryVersionsWithRawResponse,
+ MemoryVersionsWithStreamingResponse,
+ AsyncMemoryVersionsWithStreamingResponse,
+)
+
+__all__ = [
+ "Memories",
+ "AsyncMemories",
+ "MemoriesWithRawResponse",
+ "AsyncMemoriesWithRawResponse",
+ "MemoriesWithStreamingResponse",
+ "AsyncMemoriesWithStreamingResponse",
+ "MemoryVersions",
+ "AsyncMemoryVersions",
+ "MemoryVersionsWithRawResponse",
+ "AsyncMemoryVersionsWithRawResponse",
+ "MemoryVersionsWithStreamingResponse",
+ "AsyncMemoryVersionsWithStreamingResponse",
+ "MemoryStores",
+ "AsyncMemoryStores",
+ "MemoryStoresWithRawResponse",
+ "AsyncMemoryStoresWithRawResponse",
+ "MemoryStoresWithStreamingResponse",
+ "AsyncMemoryStoresWithStreamingResponse",
+]
diff --git a/src/anthropic/resources/beta/memory_stores/memories.py b/src/anthropic/resources/beta/memory_stores/memories.py
new file mode 100644
index 00000000..d9c9a82f
--- /dev/null
+++ b/src/anthropic/resources/beta/memory_stores/memories.py
@@ -0,0 +1,854 @@
+# 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.memory_stores import (
+ BetaManagedAgentsMemoryView,
+ memory_list_params,
+ memory_create_params,
+ memory_delete_params,
+ memory_update_params,
+ memory_retrieve_params,
+)
+from ....types.anthropic_beta_param import AnthropicBetaParam
+from ....types.beta.memory_stores.beta_managed_agents_memory import BetaManagedAgentsMemory
+from ....types.beta.memory_stores.beta_managed_agents_memory_view import BetaManagedAgentsMemoryView
+from ....types.beta.memory_stores.beta_managed_agents_deleted_memory import BetaManagedAgentsDeletedMemory
+from ....types.beta.memory_stores.beta_managed_agents_memory_list_item import BetaManagedAgentsMemoryListItem
+from ....types.beta.memory_stores.beta_managed_agents_precondition_param import BetaManagedAgentsPreconditionParam
+
+__all__ = ["Memories", "AsyncMemories"]
+
+
+class Memories(SyncAPIResource):
+ @cached_property
+ def with_raw_response(self) -> MemoriesWithRawResponse:
+ """
+ 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 MemoriesWithRawResponse(self)
+
+ @cached_property
+ def with_streaming_response(self) -> MemoriesWithStreamingResponse:
+ """
+ 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 MemoriesWithStreamingResponse(self)
+
+ def create(
+ self,
+ memory_store_id: str,
+ *,
+ content: Optional[str],
+ path: str,
+ view: BetaManagedAgentsMemoryView | 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,
+ ) -> BetaManagedAgentsMemory:
+ """
+ CreateMemory
+
+ Args:
+ view: Query parameter for view
+
+ 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 memory_store_id:
+ raise ValueError(f"Expected a non-empty value for `memory_store_id` but received {memory_store_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/memory_stores/{memory_store_id}/memories?beta=true", memory_store_id=memory_store_id),
+ body=maybe_transform(
+ {
+ "content": content,
+ "path": path,
+ },
+ memory_create_params.MemoryCreateParams,
+ ),
+ options=make_request_options(
+ extra_headers=extra_headers,
+ extra_query=extra_query,
+ extra_body=extra_body,
+ timeout=timeout,
+ query=maybe_transform({"view": view}, memory_create_params.MemoryCreateParams),
+ ),
+ cast_to=BetaManagedAgentsMemory,
+ )
+
+ def retrieve(
+ self,
+ memory_id: str,
+ *,
+ memory_store_id: str,
+ view: BetaManagedAgentsMemoryView | 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,
+ ) -> BetaManagedAgentsMemory:
+ """
+ GetMemory
+
+ Args:
+ view: Query parameter for view
+
+ 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 memory_store_id:
+ raise ValueError(f"Expected a non-empty value for `memory_store_id` but received {memory_store_id!r}")
+ if not memory_id:
+ raise ValueError(f"Expected a non-empty value for `memory_id` but received {memory_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/memory_stores/{memory_store_id}/memories/{memory_id}?beta=true",
+ memory_store_id=memory_store_id,
+ memory_id=memory_id,
+ ),
+ options=make_request_options(
+ extra_headers=extra_headers,
+ extra_query=extra_query,
+ extra_body=extra_body,
+ timeout=timeout,
+ query=maybe_transform({"view": view}, memory_retrieve_params.MemoryRetrieveParams),
+ ),
+ cast_to=BetaManagedAgentsMemory,
+ )
+
+ def update(
+ self,
+ memory_id: str,
+ *,
+ memory_store_id: str,
+ view: BetaManagedAgentsMemoryView | Omit = omit,
+ content: Optional[str] | Omit = omit,
+ path: Optional[str] | Omit = omit,
+ precondition: BetaManagedAgentsPreconditionParam | 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,
+ ) -> BetaManagedAgentsMemory:
+ """
+ UpdateMemory
+
+ Args:
+ view: Query parameter for view
+
+ 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 memory_store_id:
+ raise ValueError(f"Expected a non-empty value for `memory_store_id` but received {memory_store_id!r}")
+ if not memory_id:
+ raise ValueError(f"Expected a non-empty value for `memory_id` but received {memory_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/memory_stores/{memory_store_id}/memories/{memory_id}?beta=true",
+ memory_store_id=memory_store_id,
+ memory_id=memory_id,
+ ),
+ body=maybe_transform(
+ {
+ "content": content,
+ "path": path,
+ "precondition": precondition,
+ },
+ memory_update_params.MemoryUpdateParams,
+ ),
+ options=make_request_options(
+ extra_headers=extra_headers,
+ extra_query=extra_query,
+ extra_body=extra_body,
+ timeout=timeout,
+ query=maybe_transform({"view": view}, memory_update_params.MemoryUpdateParams),
+ ),
+ cast_to=BetaManagedAgentsMemory,
+ )
+
+ def list(
+ self,
+ memory_store_id: str,
+ *,
+ depth: int | Omit = omit,
+ limit: int | Omit = omit,
+ order: Literal["asc", "desc"] | Omit = omit,
+ order_by: str | Omit = omit,
+ page: str | Omit = omit,
+ path_prefix: str | Omit = omit,
+ view: BetaManagedAgentsMemoryView | 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[BetaManagedAgentsMemoryListItem]:
+ """
+ ListMemories
+
+ Args:
+ depth: Query parameter for depth
+
+ limit: Query parameter for limit
+
+ order: Query parameter for order
+
+ order_by: Query parameter for order_by
+
+ page: Query parameter for page
+
+ path_prefix: Optional path prefix filter (raw string-prefix match; include a trailing slash
+ for directory-scoped lists). This value appears in request URLs. Do not include
+ secrets or personally identifiable information.
+
+ view: Query parameter for view
+
+ 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 memory_store_id:
+ raise ValueError(f"Expected a non-empty value for `memory_store_id` but received {memory_store_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/memory_stores/{memory_store_id}/memories?beta=true", memory_store_id=memory_store_id),
+ page=SyncPageCursor[BetaManagedAgentsMemoryListItem],
+ options=make_request_options(
+ extra_headers=extra_headers,
+ extra_query=extra_query,
+ extra_body=extra_body,
+ timeout=timeout,
+ query=maybe_transform(
+ {
+ "depth": depth,
+ "limit": limit,
+ "order": order,
+ "order_by": order_by,
+ "page": page,
+ "path_prefix": path_prefix,
+ "view": view,
+ },
+ memory_list_params.MemoryListParams,
+ ),
+ ),
+ model=cast(
+ Any, BetaManagedAgentsMemoryListItem
+ ), # Union types cannot be passed in as arguments in the type system
+ )
+
+ def delete(
+ self,
+ memory_id: str,
+ *,
+ memory_store_id: str,
+ expected_content_sha256: 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,
+ ) -> BetaManagedAgentsDeletedMemory:
+ """
+ DeleteMemory
+
+ Args:
+ expected_content_sha256: Query parameter for expected_content_sha256
+
+ 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 memory_store_id:
+ raise ValueError(f"Expected a non-empty value for `memory_store_id` but received {memory_store_id!r}")
+ if not memory_id:
+ raise ValueError(f"Expected a non-empty value for `memory_id` but received {memory_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/memory_stores/{memory_store_id}/memories/{memory_id}?beta=true",
+ memory_store_id=memory_store_id,
+ memory_id=memory_id,
+ ),
+ options=make_request_options(
+ extra_headers=extra_headers,
+ extra_query=extra_query,
+ extra_body=extra_body,
+ timeout=timeout,
+ query=maybe_transform(
+ {"expected_content_sha256": expected_content_sha256}, memory_delete_params.MemoryDeleteParams
+ ),
+ ),
+ cast_to=BetaManagedAgentsDeletedMemory,
+ )
+
+
+class AsyncMemories(AsyncAPIResource):
+ @cached_property
+ def with_raw_response(self) -> AsyncMemoriesWithRawResponse:
+ """
+ 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 AsyncMemoriesWithRawResponse(self)
+
+ @cached_property
+ def with_streaming_response(self) -> AsyncMemoriesWithStreamingResponse:
+ """
+ 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 AsyncMemoriesWithStreamingResponse(self)
+
+ async def create(
+ self,
+ memory_store_id: str,
+ *,
+ content: Optional[str],
+ path: str,
+ view: BetaManagedAgentsMemoryView | 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,
+ ) -> BetaManagedAgentsMemory:
+ """
+ CreateMemory
+
+ Args:
+ view: Query parameter for view
+
+ 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 memory_store_id:
+ raise ValueError(f"Expected a non-empty value for `memory_store_id` but received {memory_store_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/memory_stores/{memory_store_id}/memories?beta=true", memory_store_id=memory_store_id),
+ body=await async_maybe_transform(
+ {
+ "content": content,
+ "path": path,
+ },
+ memory_create_params.MemoryCreateParams,
+ ),
+ options=make_request_options(
+ extra_headers=extra_headers,
+ extra_query=extra_query,
+ extra_body=extra_body,
+ timeout=timeout,
+ query=await async_maybe_transform({"view": view}, memory_create_params.MemoryCreateParams),
+ ),
+ cast_to=BetaManagedAgentsMemory,
+ )
+
+ async def retrieve(
+ self,
+ memory_id: str,
+ *,
+ memory_store_id: str,
+ view: BetaManagedAgentsMemoryView | 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,
+ ) -> BetaManagedAgentsMemory:
+ """
+ GetMemory
+
+ Args:
+ view: Query parameter for view
+
+ 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 memory_store_id:
+ raise ValueError(f"Expected a non-empty value for `memory_store_id` but received {memory_store_id!r}")
+ if not memory_id:
+ raise ValueError(f"Expected a non-empty value for `memory_id` but received {memory_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/memory_stores/{memory_store_id}/memories/{memory_id}?beta=true",
+ memory_store_id=memory_store_id,
+ memory_id=memory_id,
+ ),
+ options=make_request_options(
+ extra_headers=extra_headers,
+ extra_query=extra_query,
+ extra_body=extra_body,
+ timeout=timeout,
+ query=await async_maybe_transform({"view": view}, memory_retrieve_params.MemoryRetrieveParams),
+ ),
+ cast_to=BetaManagedAgentsMemory,
+ )
+
+ async def update(
+ self,
+ memory_id: str,
+ *,
+ memory_store_id: str,
+ view: BetaManagedAgentsMemoryView | Omit = omit,
+ content: Optional[str] | Omit = omit,
+ path: Optional[str] | Omit = omit,
+ precondition: BetaManagedAgentsPreconditionParam | 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,
+ ) -> BetaManagedAgentsMemory:
+ """
+ UpdateMemory
+
+ Args:
+ view: Query parameter for view
+
+ 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 memory_store_id:
+ raise ValueError(f"Expected a non-empty value for `memory_store_id` but received {memory_store_id!r}")
+ if not memory_id:
+ raise ValueError(f"Expected a non-empty value for `memory_id` but received {memory_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/memory_stores/{memory_store_id}/memories/{memory_id}?beta=true",
+ memory_store_id=memory_store_id,
+ memory_id=memory_id,
+ ),
+ body=await async_maybe_transform(
+ {
+ "content": content,
+ "path": path,
+ "precondition": precondition,
+ },
+ memory_update_params.MemoryUpdateParams,
+ ),
+ options=make_request_options(
+ extra_headers=extra_headers,
+ extra_query=extra_query,
+ extra_body=extra_body,
+ timeout=timeout,
+ query=await async_maybe_transform({"view": view}, memory_update_params.MemoryUpdateParams),
+ ),
+ cast_to=BetaManagedAgentsMemory,
+ )
+
+ def list(
+ self,
+ memory_store_id: str,
+ *,
+ depth: int | Omit = omit,
+ limit: int | Omit = omit,
+ order: Literal["asc", "desc"] | Omit = omit,
+ order_by: str | Omit = omit,
+ page: str | Omit = omit,
+ path_prefix: str | Omit = omit,
+ view: BetaManagedAgentsMemoryView | 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[BetaManagedAgentsMemoryListItem, AsyncPageCursor[BetaManagedAgentsMemoryListItem]]:
+ """
+ ListMemories
+
+ Args:
+ depth: Query parameter for depth
+
+ limit: Query parameter for limit
+
+ order: Query parameter for order
+
+ order_by: Query parameter for order_by
+
+ page: Query parameter for page
+
+ path_prefix: Optional path prefix filter (raw string-prefix match; include a trailing slash
+ for directory-scoped lists). This value appears in request URLs. Do not include
+ secrets or personally identifiable information.
+
+ view: Query parameter for view
+
+ 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 memory_store_id:
+ raise ValueError(f"Expected a non-empty value for `memory_store_id` but received {memory_store_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/memory_stores/{memory_store_id}/memories?beta=true", memory_store_id=memory_store_id),
+ page=AsyncPageCursor[BetaManagedAgentsMemoryListItem],
+ options=make_request_options(
+ extra_headers=extra_headers,
+ extra_query=extra_query,
+ extra_body=extra_body,
+ timeout=timeout,
+ query=maybe_transform(
+ {
+ "depth": depth,
+ "limit": limit,
+ "order": order,
+ "order_by": order_by,
+ "page": page,
+ "path_prefix": path_prefix,
+ "view": view,
+ },
+ memory_list_params.MemoryListParams,
+ ),
+ ),
+ model=cast(
+ Any, BetaManagedAgentsMemoryListItem
+ ), # Union types cannot be passed in as arguments in the type system
+ )
+
+ async def delete(
+ self,
+ memory_id: str,
+ *,
+ memory_store_id: str,
+ expected_content_sha256: 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,
+ ) -> BetaManagedAgentsDeletedMemory:
+ """
+ DeleteMemory
+
+ Args:
+ expected_content_sha256: Query parameter for expected_content_sha256
+
+ 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 memory_store_id:
+ raise ValueError(f"Expected a non-empty value for `memory_store_id` but received {memory_store_id!r}")
+ if not memory_id:
+ raise ValueError(f"Expected a non-empty value for `memory_id` but received {memory_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/memory_stores/{memory_store_id}/memories/{memory_id}?beta=true",
+ memory_store_id=memory_store_id,
+ memory_id=memory_id,
+ ),
+ options=make_request_options(
+ extra_headers=extra_headers,
+ extra_query=extra_query,
+ extra_body=extra_body,
+ timeout=timeout,
+ query=await async_maybe_transform(
+ {"expected_content_sha256": expected_content_sha256}, memory_delete_params.MemoryDeleteParams
+ ),
+ ),
+ cast_to=BetaManagedAgentsDeletedMemory,
+ )
+
+
+class MemoriesWithRawResponse:
+ def __init__(self, memories: Memories) -> None:
+ self._memories = memories
+
+ self.create = _legacy_response.to_raw_response_wrapper(
+ memories.create,
+ )
+ self.retrieve = _legacy_response.to_raw_response_wrapper(
+ memories.retrieve,
+ )
+ self.update = _legacy_response.to_raw_response_wrapper(
+ memories.update,
+ )
+ self.list = _legacy_response.to_raw_response_wrapper(
+ memories.list,
+ )
+ self.delete = _legacy_response.to_raw_response_wrapper(
+ memories.delete,
+ )
+
+
+class AsyncMemoriesWithRawResponse:
+ def __init__(self, memories: AsyncMemories) -> None:
+ self._memories = memories
+
+ self.create = _legacy_response.async_to_raw_response_wrapper(
+ memories.create,
+ )
+ self.retrieve = _legacy_response.async_to_raw_response_wrapper(
+ memories.retrieve,
+ )
+ self.update = _legacy_response.async_to_raw_response_wrapper(
+ memories.update,
+ )
+ self.list = _legacy_response.async_to_raw_response_wrapper(
+ memories.list,
+ )
+ self.delete = _legacy_response.async_to_raw_response_wrapper(
+ memories.delete,
+ )
+
+
+class MemoriesWithStreamingResponse:
+ def __init__(self, memories: Memories) -> None:
+ self._memories = memories
+
+ self.create = to_streamed_response_wrapper(
+ memories.create,
+ )
+ self.retrieve = to_streamed_response_wrapper(
+ memories.retrieve,
+ )
+ self.update = to_streamed_response_wrapper(
+ memories.update,
+ )
+ self.list = to_streamed_response_wrapper(
+ memories.list,
+ )
+ self.delete = to_streamed_response_wrapper(
+ memories.delete,
+ )
+
+
+class AsyncMemoriesWithStreamingResponse:
+ def __init__(self, memories: AsyncMemories) -> None:
+ self._memories = memories
+
+ self.create = async_to_streamed_response_wrapper(
+ memories.create,
+ )
+ self.retrieve = async_to_streamed_response_wrapper(
+ memories.retrieve,
+ )
+ self.update = async_to_streamed_response_wrapper(
+ memories.update,
+ )
+ self.list = async_to_streamed_response_wrapper(
+ memories.list,
+ )
+ self.delete = async_to_streamed_response_wrapper(
+ memories.delete,
+ )
diff --git a/src/anthropic/resources/beta/memory_stores/memory_stores.py b/src/anthropic/resources/beta/memory_stores/memory_stores.py
new file mode 100644
index 00000000..707584af
--- /dev/null
+++ b/src/anthropic/resources/beta/memory_stores/memory_stores.py
@@ -0,0 +1,890 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, List, Union, Optional
+from datetime import datetime
+from itertools import chain
+
+import httpx
+
+from .... import _legacy_response
+from .memories import (
+ Memories,
+ AsyncMemories,
+ MemoriesWithRawResponse,
+ AsyncMemoriesWithRawResponse,
+ MemoriesWithStreamingResponse,
+ AsyncMemoriesWithStreamingResponse,
+)
+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 memory_store_list_params, memory_store_create_params, memory_store_update_params
+from ...._base_client import AsyncPaginator, make_request_options
+from .memory_versions import (
+ MemoryVersions,
+ AsyncMemoryVersions,
+ MemoryVersionsWithRawResponse,
+ AsyncMemoryVersionsWithRawResponse,
+ MemoryVersionsWithStreamingResponse,
+ AsyncMemoryVersionsWithStreamingResponse,
+)
+from ....types.anthropic_beta_param import AnthropicBetaParam
+from ....types.beta.beta_managed_agents_memory_store import BetaManagedAgentsMemoryStore
+from ....types.beta.beta_managed_agents_deleted_memory_store import BetaManagedAgentsDeletedMemoryStore
+
+__all__ = ["MemoryStores", "AsyncMemoryStores"]
+
+
+class MemoryStores(SyncAPIResource):
+ @cached_property
+ def memories(self) -> Memories:
+ return Memories(self._client)
+
+ @cached_property
+ def memory_versions(self) -> MemoryVersions:
+ return MemoryVersions(self._client)
+
+ @cached_property
+ def with_raw_response(self) -> MemoryStoresWithRawResponse:
+ """
+ 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 MemoryStoresWithRawResponse(self)
+
+ @cached_property
+ def with_streaming_response(self) -> MemoryStoresWithStreamingResponse:
+ """
+ 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 MemoryStoresWithStreamingResponse(self)
+
+ def create(
+ self,
+ *,
+ name: str,
+ description: 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,
+ ) -> BetaManagedAgentsMemoryStore:
+ """
+ CreateMemoryStore
+
+ 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
+ """
+ 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/memory_stores?beta=true",
+ body=maybe_transform(
+ {
+ "name": name,
+ "description": description,
+ "metadata": metadata,
+ },
+ memory_store_create_params.MemoryStoreCreateParams,
+ ),
+ options=make_request_options(
+ extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+ ),
+ cast_to=BetaManagedAgentsMemoryStore,
+ )
+
+ def retrieve(
+ self,
+ memory_store_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,
+ ) -> BetaManagedAgentsMemoryStore:
+ """
+ GetMemoryStore
+
+ 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 memory_store_id:
+ raise ValueError(f"Expected a non-empty value for `memory_store_id` but received {memory_store_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/memory_stores/{memory_store_id}?beta=true", memory_store_id=memory_store_id),
+ options=make_request_options(
+ extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+ ),
+ cast_to=BetaManagedAgentsMemoryStore,
+ )
+
+ def update(
+ self,
+ memory_store_id: str,
+ *,
+ description: Optional[str] | Omit = omit,
+ metadata: Optional[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,
+ ) -> BetaManagedAgentsMemoryStore:
+ """UpdateMemoryStore
+
+ Args:
+ 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.
+
+ 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 memory_store_id:
+ raise ValueError(f"Expected a non-empty value for `memory_store_id` but received {memory_store_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/memory_stores/{memory_store_id}?beta=true", memory_store_id=memory_store_id),
+ body=maybe_transform(
+ {
+ "description": description,
+ "metadata": metadata,
+ "name": name,
+ },
+ memory_store_update_params.MemoryStoreUpdateParams,
+ ),
+ options=make_request_options(
+ extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+ ),
+ cast_to=BetaManagedAgentsMemoryStore,
+ )
+
+ 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[BetaManagedAgentsMemoryStore]:
+ """
+ ListMemoryStores
+
+ Args:
+ created_at_gte: Return stores created at or after this time (inclusive).
+
+ created_at_lte: Return stores created at or before this time (inclusive).
+
+ include_archived: Query parameter for include_archived
+
+ limit: Query parameter for limit
+
+ 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), ["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/memory_stores?beta=true",
+ page=SyncPageCursor[BetaManagedAgentsMemoryStore],
+ 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,
+ },
+ memory_store_list_params.MemoryStoreListParams,
+ ),
+ ),
+ model=BetaManagedAgentsMemoryStore,
+ )
+
+ def delete(
+ self,
+ memory_store_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,
+ ) -> BetaManagedAgentsDeletedMemoryStore:
+ """
+ DeleteMemoryStore
+
+ 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 memory_store_id:
+ raise ValueError(f"Expected a non-empty value for `memory_store_id` but received {memory_store_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/memory_stores/{memory_store_id}?beta=true", memory_store_id=memory_store_id),
+ options=make_request_options(
+ extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+ ),
+ cast_to=BetaManagedAgentsDeletedMemoryStore,
+ )
+
+ def archive(
+ self,
+ memory_store_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,
+ ) -> BetaManagedAgentsMemoryStore:
+ """
+ ArchiveMemoryStore
+
+ 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 memory_store_id:
+ raise ValueError(f"Expected a non-empty value for `memory_store_id` but received {memory_store_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/memory_stores/{memory_store_id}/archive?beta=true", memory_store_id=memory_store_id),
+ options=make_request_options(
+ extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+ ),
+ cast_to=BetaManagedAgentsMemoryStore,
+ )
+
+
+class AsyncMemoryStores(AsyncAPIResource):
+ @cached_property
+ def memories(self) -> AsyncMemories:
+ return AsyncMemories(self._client)
+
+ @cached_property
+ def memory_versions(self) -> AsyncMemoryVersions:
+ return AsyncMemoryVersions(self._client)
+
+ @cached_property
+ def with_raw_response(self) -> AsyncMemoryStoresWithRawResponse:
+ """
+ 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 AsyncMemoryStoresWithRawResponse(self)
+
+ @cached_property
+ def with_streaming_response(self) -> AsyncMemoryStoresWithStreamingResponse:
+ """
+ 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 AsyncMemoryStoresWithStreamingResponse(self)
+
+ async def create(
+ self,
+ *,
+ name: str,
+ description: 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,
+ ) -> BetaManagedAgentsMemoryStore:
+ """
+ CreateMemoryStore
+
+ 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
+ """
+ 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/memory_stores?beta=true",
+ body=await async_maybe_transform(
+ {
+ "name": name,
+ "description": description,
+ "metadata": metadata,
+ },
+ memory_store_create_params.MemoryStoreCreateParams,
+ ),
+ options=make_request_options(
+ extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+ ),
+ cast_to=BetaManagedAgentsMemoryStore,
+ )
+
+ async def retrieve(
+ self,
+ memory_store_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,
+ ) -> BetaManagedAgentsMemoryStore:
+ """
+ GetMemoryStore
+
+ 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 memory_store_id:
+ raise ValueError(f"Expected a non-empty value for `memory_store_id` but received {memory_store_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/memory_stores/{memory_store_id}?beta=true", memory_store_id=memory_store_id),
+ options=make_request_options(
+ extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+ ),
+ cast_to=BetaManagedAgentsMemoryStore,
+ )
+
+ async def update(
+ self,
+ memory_store_id: str,
+ *,
+ description: Optional[str] | Omit = omit,
+ metadata: Optional[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,
+ ) -> BetaManagedAgentsMemoryStore:
+ """UpdateMemoryStore
+
+ Args:
+ 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.
+
+ 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 memory_store_id:
+ raise ValueError(f"Expected a non-empty value for `memory_store_id` but received {memory_store_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/memory_stores/{memory_store_id}?beta=true", memory_store_id=memory_store_id),
+ body=await async_maybe_transform(
+ {
+ "description": description,
+ "metadata": metadata,
+ "name": name,
+ },
+ memory_store_update_params.MemoryStoreUpdateParams,
+ ),
+ options=make_request_options(
+ extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+ ),
+ cast_to=BetaManagedAgentsMemoryStore,
+ )
+
+ 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[BetaManagedAgentsMemoryStore, AsyncPageCursor[BetaManagedAgentsMemoryStore]]:
+ """
+ ListMemoryStores
+
+ Args:
+ created_at_gte: Return stores created at or after this time (inclusive).
+
+ created_at_lte: Return stores created at or before this time (inclusive).
+
+ include_archived: Query parameter for include_archived
+
+ limit: Query parameter for limit
+
+ 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), ["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/memory_stores?beta=true",
+ page=AsyncPageCursor[BetaManagedAgentsMemoryStore],
+ 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,
+ },
+ memory_store_list_params.MemoryStoreListParams,
+ ),
+ ),
+ model=BetaManagedAgentsMemoryStore,
+ )
+
+ async def delete(
+ self,
+ memory_store_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,
+ ) -> BetaManagedAgentsDeletedMemoryStore:
+ """
+ DeleteMemoryStore
+
+ 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 memory_store_id:
+ raise ValueError(f"Expected a non-empty value for `memory_store_id` but received {memory_store_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/memory_stores/{memory_store_id}?beta=true", memory_store_id=memory_store_id),
+ options=make_request_options(
+ extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+ ),
+ cast_to=BetaManagedAgentsDeletedMemoryStore,
+ )
+
+ async def archive(
+ self,
+ memory_store_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,
+ ) -> BetaManagedAgentsMemoryStore:
+ """
+ ArchiveMemoryStore
+
+ 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 memory_store_id:
+ raise ValueError(f"Expected a non-empty value for `memory_store_id` but received {memory_store_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/memory_stores/{memory_store_id}/archive?beta=true", memory_store_id=memory_store_id),
+ options=make_request_options(
+ extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+ ),
+ cast_to=BetaManagedAgentsMemoryStore,
+ )
+
+
+class MemoryStoresWithRawResponse:
+ def __init__(self, memory_stores: MemoryStores) -> None:
+ self._memory_stores = memory_stores
+
+ self.create = _legacy_response.to_raw_response_wrapper(
+ memory_stores.create,
+ )
+ self.retrieve = _legacy_response.to_raw_response_wrapper(
+ memory_stores.retrieve,
+ )
+ self.update = _legacy_response.to_raw_response_wrapper(
+ memory_stores.update,
+ )
+ self.list = _legacy_response.to_raw_response_wrapper(
+ memory_stores.list,
+ )
+ self.delete = _legacy_response.to_raw_response_wrapper(
+ memory_stores.delete,
+ )
+ self.archive = _legacy_response.to_raw_response_wrapper(
+ memory_stores.archive,
+ )
+
+ @cached_property
+ def memories(self) -> MemoriesWithRawResponse:
+ return MemoriesWithRawResponse(self._memory_stores.memories)
+
+ @cached_property
+ def memory_versions(self) -> MemoryVersionsWithRawResponse:
+ return MemoryVersionsWithRawResponse(self._memory_stores.memory_versions)
+
+
+class AsyncMemoryStoresWithRawResponse:
+ def __init__(self, memory_stores: AsyncMemoryStores) -> None:
+ self._memory_stores = memory_stores
+
+ self.create = _legacy_response.async_to_raw_response_wrapper(
+ memory_stores.create,
+ )
+ self.retrieve = _legacy_response.async_to_raw_response_wrapper(
+ memory_stores.retrieve,
+ )
+ self.update = _legacy_response.async_to_raw_response_wrapper(
+ memory_stores.update,
+ )
+ self.list = _legacy_response.async_to_raw_response_wrapper(
+ memory_stores.list,
+ )
+ self.delete = _legacy_response.async_to_raw_response_wrapper(
+ memory_stores.delete,
+ )
+ self.archive = _legacy_response.async_to_raw_response_wrapper(
+ memory_stores.archive,
+ )
+
+ @cached_property
+ def memories(self) -> AsyncMemoriesWithRawResponse:
+ return AsyncMemoriesWithRawResponse(self._memory_stores.memories)
+
+ @cached_property
+ def memory_versions(self) -> AsyncMemoryVersionsWithRawResponse:
+ return AsyncMemoryVersionsWithRawResponse(self._memory_stores.memory_versions)
+
+
+class MemoryStoresWithStreamingResponse:
+ def __init__(self, memory_stores: MemoryStores) -> None:
+ self._memory_stores = memory_stores
+
+ self.create = to_streamed_response_wrapper(
+ memory_stores.create,
+ )
+ self.retrieve = to_streamed_response_wrapper(
+ memory_stores.retrieve,
+ )
+ self.update = to_streamed_response_wrapper(
+ memory_stores.update,
+ )
+ self.list = to_streamed_response_wrapper(
+ memory_stores.list,
+ )
+ self.delete = to_streamed_response_wrapper(
+ memory_stores.delete,
+ )
+ self.archive = to_streamed_response_wrapper(
+ memory_stores.archive,
+ )
+
+ @cached_property
+ def memories(self) -> MemoriesWithStreamingResponse:
+ return MemoriesWithStreamingResponse(self._memory_stores.memories)
+
+ @cached_property
+ def memory_versions(self) -> MemoryVersionsWithStreamingResponse:
+ return MemoryVersionsWithStreamingResponse(self._memory_stores.memory_versions)
+
+
+class AsyncMemoryStoresWithStreamingResponse:
+ def __init__(self, memory_stores: AsyncMemoryStores) -> None:
+ self._memory_stores = memory_stores
+
+ self.create = async_to_streamed_response_wrapper(
+ memory_stores.create,
+ )
+ self.retrieve = async_to_streamed_response_wrapper(
+ memory_stores.retrieve,
+ )
+ self.update = async_to_streamed_response_wrapper(
+ memory_stores.update,
+ )
+ self.list = async_to_streamed_response_wrapper(
+ memory_stores.list,
+ )
+ self.delete = async_to_streamed_response_wrapper(
+ memory_stores.delete,
+ )
+ self.archive = async_to_streamed_response_wrapper(
+ memory_stores.archive,
+ )
+
+ @cached_property
+ def memories(self) -> AsyncMemoriesWithStreamingResponse:
+ return AsyncMemoriesWithStreamingResponse(self._memory_stores.memories)
+
+ @cached_property
+ def memory_versions(self) -> AsyncMemoryVersionsWithStreamingResponse:
+ return AsyncMemoryVersionsWithStreamingResponse(self._memory_stores.memory_versions)
diff --git a/src/anthropic/resources/beta/memory_stores/memory_versions.py b/src/anthropic/resources/beta/memory_stores/memory_versions.py
new file mode 100644
index 00000000..36cb5a23
--- /dev/null
+++ b/src/anthropic/resources/beta/memory_stores/memory_versions.py
@@ -0,0 +1,554 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Union
+from datetime import datetime
+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.memory_stores import (
+ BetaManagedAgentsMemoryView,
+ BetaManagedAgentsMemoryVersionOperation,
+ memory_version_list_params,
+ memory_version_retrieve_params,
+)
+from ....types.anthropic_beta_param import AnthropicBetaParam
+from ....types.beta.memory_stores.beta_managed_agents_memory_view import BetaManagedAgentsMemoryView
+from ....types.beta.memory_stores.beta_managed_agents_memory_version import BetaManagedAgentsMemoryVersion
+from ....types.beta.memory_stores.beta_managed_agents_memory_version_operation import (
+ BetaManagedAgentsMemoryVersionOperation,
+)
+
+__all__ = ["MemoryVersions", "AsyncMemoryVersions"]
+
+
+class MemoryVersions(SyncAPIResource):
+ @cached_property
+ def with_raw_response(self) -> MemoryVersionsWithRawResponse:
+ """
+ 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 MemoryVersionsWithRawResponse(self)
+
+ @cached_property
+ def with_streaming_response(self) -> MemoryVersionsWithStreamingResponse:
+ """
+ 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 MemoryVersionsWithStreamingResponse(self)
+
+ def retrieve(
+ self,
+ memory_version_id: str,
+ *,
+ memory_store_id: str,
+ view: BetaManagedAgentsMemoryView | 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,
+ ) -> BetaManagedAgentsMemoryVersion:
+ """
+ GetMemoryVersion
+
+ Args:
+ view: Query parameter for view
+
+ 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 memory_store_id:
+ raise ValueError(f"Expected a non-empty value for `memory_store_id` but received {memory_store_id!r}")
+ if not memory_version_id:
+ raise ValueError(f"Expected a non-empty value for `memory_version_id` but received {memory_version_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/memory_stores/{memory_store_id}/memory_versions/{memory_version_id}?beta=true",
+ memory_store_id=memory_store_id,
+ memory_version_id=memory_version_id,
+ ),
+ options=make_request_options(
+ extra_headers=extra_headers,
+ extra_query=extra_query,
+ extra_body=extra_body,
+ timeout=timeout,
+ query=maybe_transform({"view": view}, memory_version_retrieve_params.MemoryVersionRetrieveParams),
+ ),
+ cast_to=BetaManagedAgentsMemoryVersion,
+ )
+
+ def list(
+ self,
+ memory_store_id: str,
+ *,
+ api_key_id: str | Omit = omit,
+ created_at_gte: Union[str, datetime] | Omit = omit,
+ created_at_lte: Union[str, datetime] | Omit = omit,
+ limit: int | Omit = omit,
+ memory_id: str | Omit = omit,
+ operation: BetaManagedAgentsMemoryVersionOperation | Omit = omit,
+ page: str | Omit = omit,
+ session_id: str | Omit = omit,
+ view: BetaManagedAgentsMemoryView | 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[BetaManagedAgentsMemoryVersion]:
+ """
+ ListMemoryVersions
+
+ Args:
+ api_key_id: Query parameter for api_key_id
+
+ created_at_gte: Return versions created at or after this time (inclusive).
+
+ created_at_lte: Return versions created at or before this time (inclusive).
+
+ limit: Query parameter for limit
+
+ memory_id: Query parameter for memory_id
+
+ operation: Query parameter for operation
+
+ page: Query parameter for page
+
+ session_id: Query parameter for session_id
+
+ view: Query parameter for view
+
+ 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 memory_store_id:
+ raise ValueError(f"Expected a non-empty value for `memory_store_id` but received {memory_store_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/memory_stores/{memory_store_id}/memory_versions?beta=true", memory_store_id=memory_store_id
+ ),
+ page=SyncPageCursor[BetaManagedAgentsMemoryVersion],
+ options=make_request_options(
+ extra_headers=extra_headers,
+ extra_query=extra_query,
+ extra_body=extra_body,
+ timeout=timeout,
+ query=maybe_transform(
+ {
+ "api_key_id": api_key_id,
+ "created_at_gte": created_at_gte,
+ "created_at_lte": created_at_lte,
+ "limit": limit,
+ "memory_id": memory_id,
+ "operation": operation,
+ "page": page,
+ "session_id": session_id,
+ "view": view,
+ },
+ memory_version_list_params.MemoryVersionListParams,
+ ),
+ ),
+ model=BetaManagedAgentsMemoryVersion,
+ )
+
+ def redact(
+ self,
+ memory_version_id: str,
+ *,
+ memory_store_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,
+ ) -> BetaManagedAgentsMemoryVersion:
+ """
+ RedactMemoryVersion
+
+ 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 memory_store_id:
+ raise ValueError(f"Expected a non-empty value for `memory_store_id` but received {memory_store_id!r}")
+ if not memory_version_id:
+ raise ValueError(f"Expected a non-empty value for `memory_version_id` but received {memory_version_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/memory_stores/{memory_store_id}/memory_versions/{memory_version_id}/redact?beta=true",
+ memory_store_id=memory_store_id,
+ memory_version_id=memory_version_id,
+ ),
+ options=make_request_options(
+ extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+ ),
+ cast_to=BetaManagedAgentsMemoryVersion,
+ )
+
+
+class AsyncMemoryVersions(AsyncAPIResource):
+ @cached_property
+ def with_raw_response(self) -> AsyncMemoryVersionsWithRawResponse:
+ """
+ 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 AsyncMemoryVersionsWithRawResponse(self)
+
+ @cached_property
+ def with_streaming_response(self) -> AsyncMemoryVersionsWithStreamingResponse:
+ """
+ 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 AsyncMemoryVersionsWithStreamingResponse(self)
+
+ async def retrieve(
+ self,
+ memory_version_id: str,
+ *,
+ memory_store_id: str,
+ view: BetaManagedAgentsMemoryView | 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,
+ ) -> BetaManagedAgentsMemoryVersion:
+ """
+ GetMemoryVersion
+
+ Args:
+ view: Query parameter for view
+
+ 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 memory_store_id:
+ raise ValueError(f"Expected a non-empty value for `memory_store_id` but received {memory_store_id!r}")
+ if not memory_version_id:
+ raise ValueError(f"Expected a non-empty value for `memory_version_id` but received {memory_version_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/memory_stores/{memory_store_id}/memory_versions/{memory_version_id}?beta=true",
+ memory_store_id=memory_store_id,
+ memory_version_id=memory_version_id,
+ ),
+ options=make_request_options(
+ extra_headers=extra_headers,
+ extra_query=extra_query,
+ extra_body=extra_body,
+ timeout=timeout,
+ query=await async_maybe_transform(
+ {"view": view}, memory_version_retrieve_params.MemoryVersionRetrieveParams
+ ),
+ ),
+ cast_to=BetaManagedAgentsMemoryVersion,
+ )
+
+ def list(
+ self,
+ memory_store_id: str,
+ *,
+ api_key_id: str | Omit = omit,
+ created_at_gte: Union[str, datetime] | Omit = omit,
+ created_at_lte: Union[str, datetime] | Omit = omit,
+ limit: int | Omit = omit,
+ memory_id: str | Omit = omit,
+ operation: BetaManagedAgentsMemoryVersionOperation | Omit = omit,
+ page: str | Omit = omit,
+ session_id: str | Omit = omit,
+ view: BetaManagedAgentsMemoryView | 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[BetaManagedAgentsMemoryVersion, AsyncPageCursor[BetaManagedAgentsMemoryVersion]]:
+ """
+ ListMemoryVersions
+
+ Args:
+ api_key_id: Query parameter for api_key_id
+
+ created_at_gte: Return versions created at or after this time (inclusive).
+
+ created_at_lte: Return versions created at or before this time (inclusive).
+
+ limit: Query parameter for limit
+
+ memory_id: Query parameter for memory_id
+
+ operation: Query parameter for operation
+
+ page: Query parameter for page
+
+ session_id: Query parameter for session_id
+
+ view: Query parameter for view
+
+ 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 memory_store_id:
+ raise ValueError(f"Expected a non-empty value for `memory_store_id` but received {memory_store_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/memory_stores/{memory_store_id}/memory_versions?beta=true", memory_store_id=memory_store_id
+ ),
+ page=AsyncPageCursor[BetaManagedAgentsMemoryVersion],
+ options=make_request_options(
+ extra_headers=extra_headers,
+ extra_query=extra_query,
+ extra_body=extra_body,
+ timeout=timeout,
+ query=maybe_transform(
+ {
+ "api_key_id": api_key_id,
+ "created_at_gte": created_at_gte,
+ "created_at_lte": created_at_lte,
+ "limit": limit,
+ "memory_id": memory_id,
+ "operation": operation,
+ "page": page,
+ "session_id": session_id,
+ "view": view,
+ },
+ memory_version_list_params.MemoryVersionListParams,
+ ),
+ ),
+ model=BetaManagedAgentsMemoryVersion,
+ )
+
+ async def redact(
+ self,
+ memory_version_id: str,
+ *,
+ memory_store_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,
+ ) -> BetaManagedAgentsMemoryVersion:
+ """
+ RedactMemoryVersion
+
+ 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 memory_store_id:
+ raise ValueError(f"Expected a non-empty value for `memory_store_id` but received {memory_store_id!r}")
+ if not memory_version_id:
+ raise ValueError(f"Expected a non-empty value for `memory_version_id` but received {memory_version_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/memory_stores/{memory_store_id}/memory_versions/{memory_version_id}/redact?beta=true",
+ memory_store_id=memory_store_id,
+ memory_version_id=memory_version_id,
+ ),
+ options=make_request_options(
+ extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+ ),
+ cast_to=BetaManagedAgentsMemoryVersion,
+ )
+
+
+class MemoryVersionsWithRawResponse:
+ def __init__(self, memory_versions: MemoryVersions) -> None:
+ self._memory_versions = memory_versions
+
+ self.retrieve = _legacy_response.to_raw_response_wrapper(
+ memory_versions.retrieve,
+ )
+ self.list = _legacy_response.to_raw_response_wrapper(
+ memory_versions.list,
+ )
+ self.redact = _legacy_response.to_raw_response_wrapper(
+ memory_versions.redact,
+ )
+
+
+class AsyncMemoryVersionsWithRawResponse:
+ def __init__(self, memory_versions: AsyncMemoryVersions) -> None:
+ self._memory_versions = memory_versions
+
+ self.retrieve = _legacy_response.async_to_raw_response_wrapper(
+ memory_versions.retrieve,
+ )
+ self.list = _legacy_response.async_to_raw_response_wrapper(
+ memory_versions.list,
+ )
+ self.redact = _legacy_response.async_to_raw_response_wrapper(
+ memory_versions.redact,
+ )
+
+
+class MemoryVersionsWithStreamingResponse:
+ def __init__(self, memory_versions: MemoryVersions) -> None:
+ self._memory_versions = memory_versions
+
+ self.retrieve = to_streamed_response_wrapper(
+ memory_versions.retrieve,
+ )
+ self.list = to_streamed_response_wrapper(
+ memory_versions.list,
+ )
+ self.redact = to_streamed_response_wrapper(
+ memory_versions.redact,
+ )
+
+
+class AsyncMemoryVersionsWithStreamingResponse:
+ def __init__(self, memory_versions: AsyncMemoryVersions) -> None:
+ self._memory_versions = memory_versions
+
+ self.retrieve = async_to_streamed_response_wrapper(
+ memory_versions.retrieve,
+ )
+ self.list = async_to_streamed_response_wrapper(
+ memory_versions.list,
+ )
+ self.redact = async_to_streamed_response_wrapper(
+ memory_versions.redact,
+ )
diff --git a/src/anthropic/resources/beta/messages/messages.py b/src/anthropic/resources/beta/messages/messages.py
index 6a38078d..e3e10e09 100644
--- a/src/anthropic/resources/beta/messages/messages.py
+++ b/src/anthropic/resources/beta/messages/messages.py
@@ -386,18 +386,15 @@ def create(
Used to remove "long tail" low probability responses.
[Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
top_p: Use nucleus sampling.
In nucleus sampling, we compute the cumulative distribution over all the options
for each subsequent token in decreasing probability order and cut it off once it
- reaches a particular probability specified by `top_p`. You should either alter
- `temperature` or `top_p`, but not both.
+ reaches a particular probability specified by `top_p`.
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
user_profile_id: The user profile ID to attribute this request to. Use when acting on behalf of a
party other than your organization.
@@ -695,18 +692,15 @@ def create(
Used to remove "long tail" low probability responses.
[Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
top_p: Use nucleus sampling.
In nucleus sampling, we compute the cumulative distribution over all the options
for each subsequent token in decreasing probability order and cut it off once it
- reaches a particular probability specified by `top_p`. You should either alter
- `temperature` or `top_p`, but not both.
+ reaches a particular probability specified by `top_p`.
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
user_profile_id: The user profile ID to attribute this request to. Use when acting on behalf of a
party other than your organization.
@@ -1004,18 +998,15 @@ def create(
Used to remove "long tail" low probability responses.
[Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
top_p: Use nucleus sampling.
In nucleus sampling, we compute the cumulative distribution over all the options
for each subsequent token in decreasing probability order and cut it off once it
- reaches a particular probability specified by `top_p`. You should either alter
- `temperature` or `top_p`, but not both.
+ reaches a particular probability specified by `top_p`.
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
user_profile_id: The user profile ID to attribute this request to. Use when acting on behalf of a
party other than your organization.
@@ -2223,18 +2214,15 @@ async def create(
Used to remove "long tail" low probability responses.
[Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
top_p: Use nucleus sampling.
In nucleus sampling, we compute the cumulative distribution over all the options
for each subsequent token in decreasing probability order and cut it off once it
- reaches a particular probability specified by `top_p`. You should either alter
- `temperature` or `top_p`, but not both.
+ reaches a particular probability specified by `top_p`.
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
user_profile_id: The user profile ID to attribute this request to. Use when acting on behalf of a
party other than your organization.
@@ -2532,18 +2520,15 @@ async def create(
Used to remove "long tail" low probability responses.
[Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
top_p: Use nucleus sampling.
In nucleus sampling, we compute the cumulative distribution over all the options
for each subsequent token in decreasing probability order and cut it off once it
- reaches a particular probability specified by `top_p`. You should either alter
- `temperature` or `top_p`, but not both.
+ reaches a particular probability specified by `top_p`.
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
user_profile_id: The user profile ID to attribute this request to. Use when acting on behalf of a
party other than your organization.
@@ -2841,18 +2826,15 @@ async def create(
Used to remove "long tail" low probability responses.
[Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
top_p: Use nucleus sampling.
In nucleus sampling, we compute the cumulative distribution over all the options
for each subsequent token in decreasing probability order and cut it off once it
- reaches a particular probability specified by `top_p`. You should either alter
- `temperature` or `top_p`, but not both.
+ reaches a particular probability specified by `top_p`.
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
user_profile_id: The user profile ID to attribute this request to. Use when acting on behalf of a
party other than your organization.
diff --git a/src/anthropic/resources/beta/skills/skills.py b/src/anthropic/resources/beta/skills/skills.py
index 861a0f93..b2241a6d 100644
--- a/src/anthropic/resources/beta/skills/skills.py
+++ b/src/anthropic/resources/beta/skills/skills.py
@@ -16,6 +16,7 @@
VersionsWithStreamingResponse,
AsyncVersionsWithStreamingResponse,
)
+from ...._files import deepcopy_with_paths
from ...._types import (
Body,
Omit,
@@ -27,15 +28,7 @@
omit,
not_given,
)
-from ...._utils import (
- is_given,
- extract_files,
- path_template,
- maybe_transform,
- strip_not_given,
- deepcopy_minimal,
- async_maybe_transform,
-)
+from ...._utils import is_given, extract_files, 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
@@ -123,11 +116,12 @@ def create(
**(extra_headers or {}),
}
extra_headers = {"anthropic-beta": "skills-2025-10-02", **(extra_headers or {})}
- body = deepcopy_minimal(
+ body = deepcopy_with_paths(
{
"display_title": display_title,
"files": files,
- }
+ },
+ [["files", ""]],
)
extracted_files = extract_files(cast(Mapping[str, object], body), paths=[["files", ""]])
# It should be noted that the actual Content-Type header that will be
@@ -394,11 +388,12 @@ async def create(
**(extra_headers or {}),
}
extra_headers = {"anthropic-beta": "skills-2025-10-02", **(extra_headers or {})}
- body = deepcopy_minimal(
+ body = deepcopy_with_paths(
{
"display_title": display_title,
"files": files,
- }
+ },
+ [["files", ""]],
)
extracted_files = extract_files(cast(Mapping[str, object], body), paths=[["files", ""]])
# It should be noted that the actual Content-Type header that will be
diff --git a/src/anthropic/resources/beta/skills/versions.py b/src/anthropic/resources/beta/skills/versions.py
index a0cc0bd6..d849f45d 100644
--- a/src/anthropic/resources/beta/skills/versions.py
+++ b/src/anthropic/resources/beta/skills/versions.py
@@ -8,6 +8,7 @@
import httpx
from .... import _legacy_response
+from ...._files import deepcopy_with_paths
from ...._types import (
Body,
Omit,
@@ -19,15 +20,7 @@
omit,
not_given,
)
-from ...._utils import (
- is_given,
- extract_files,
- path_template,
- maybe_transform,
- strip_not_given,
- deepcopy_minimal,
- async_maybe_transform,
-)
+from ...._utils import is_given, extract_files, 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
@@ -112,7 +105,7 @@ def create(
**(extra_headers or {}),
}
extra_headers = {"anthropic-beta": "skills-2025-10-02", **(extra_headers or {})}
- body = deepcopy_minimal({"files": files})
+ body = deepcopy_with_paths({"files": files}, [["files", ""]])
extracted_files = extract_files(cast(Mapping[str, object], body), paths=[["files", ""]])
# It should be noted that the actual Content-Type header that will be
# sent to the server will contain a `boundary` parameter, e.g.
@@ -384,7 +377,7 @@ async def create(
**(extra_headers or {}),
}
extra_headers = {"anthropic-beta": "skills-2025-10-02", **(extra_headers or {})}
- body = deepcopy_minimal({"files": files})
+ body = deepcopy_with_paths({"files": files}, [["files", ""]])
extracted_files = extract_files(cast(Mapping[str, object], body), paths=[["files", ""]])
# It should be noted that the actual Content-Type header that will be
# sent to the server will contain a `boundary` parameter, e.g.
diff --git a/src/anthropic/resources/completions.py b/src/anthropic/resources/completions.py
index 563491f8..6162e168 100644
--- a/src/anthropic/resources/completions.py
+++ b/src/anthropic/resources/completions.py
@@ -126,18 +126,15 @@ def create(
Used to remove "long tail" low probability responses.
[Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
top_p: Use nucleus sampling.
In nucleus sampling, we compute the cumulative distribution over all the options
for each subsequent token in decreasing probability order and cut it off once it
- reaches a particular probability specified by `top_p`. You should either alter
- `temperature` or `top_p`, but not both.
+ reaches a particular probability specified by `top_p`.
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
betas: Optional header to specify the beta version(s) you want to use.
@@ -232,18 +229,15 @@ def create(
Used to remove "long tail" low probability responses.
[Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
top_p: Use nucleus sampling.
In nucleus sampling, we compute the cumulative distribution over all the options
for each subsequent token in decreasing probability order and cut it off once it
- reaches a particular probability specified by `top_p`. You should either alter
- `temperature` or `top_p`, but not both.
+ reaches a particular probability specified by `top_p`.
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
betas: Optional header to specify the beta version(s) you want to use.
@@ -338,18 +332,15 @@ def create(
Used to remove "long tail" low probability responses.
[Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
top_p: Use nucleus sampling.
In nucleus sampling, we compute the cumulative distribution over all the options
for each subsequent token in decreasing probability order and cut it off once it
- reaches a particular probability specified by `top_p`. You should either alter
- `temperature` or `top_p`, but not both.
+ reaches a particular probability specified by `top_p`.
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
betas: Optional header to specify the beta version(s) you want to use.
@@ -518,18 +509,15 @@ async def create(
Used to remove "long tail" low probability responses.
[Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
top_p: Use nucleus sampling.
In nucleus sampling, we compute the cumulative distribution over all the options
for each subsequent token in decreasing probability order and cut it off once it
- reaches a particular probability specified by `top_p`. You should either alter
- `temperature` or `top_p`, but not both.
+ reaches a particular probability specified by `top_p`.
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
betas: Optional header to specify the beta version(s) you want to use.
@@ -624,18 +612,15 @@ async def create(
Used to remove "long tail" low probability responses.
[Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
top_p: Use nucleus sampling.
In nucleus sampling, we compute the cumulative distribution over all the options
for each subsequent token in decreasing probability order and cut it off once it
- reaches a particular probability specified by `top_p`. You should either alter
- `temperature` or `top_p`, but not both.
+ reaches a particular probability specified by `top_p`.
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
betas: Optional header to specify the beta version(s) you want to use.
@@ -730,18 +715,15 @@ async def create(
Used to remove "long tail" low probability responses.
[Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
top_p: Use nucleus sampling.
In nucleus sampling, we compute the cumulative distribution over all the options
for each subsequent token in decreasing probability order and cut it off once it
- reaches a particular probability specified by `top_p`. You should either alter
- `temperature` or `top_p`, but not both.
+ reaches a particular probability specified by `top_p`.
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
betas: Optional header to specify the beta version(s) you want to use.
diff --git a/src/anthropic/resources/messages/messages.py b/src/anthropic/resources/messages/messages.py
index 52378bd9..35471ea4 100644
--- a/src/anthropic/resources/messages/messages.py
+++ b/src/anthropic/resources/messages/messages.py
@@ -362,18 +362,15 @@ def create(
Used to remove "long tail" low probability responses.
[Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
top_p: Use nucleus sampling.
In nucleus sampling, we compute the cumulative distribution over all the options
for each subsequent token in decreasing probability order and cut it off once it
- reaches a particular probability specified by `top_p`. You should either alter
- `temperature` or `top_p`, but not both.
+ reaches a particular probability specified by `top_p`.
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
extra_headers: Send extra headers
@@ -644,18 +641,15 @@ def create(
Used to remove "long tail" low probability responses.
[Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
top_p: Use nucleus sampling.
In nucleus sampling, we compute the cumulative distribution over all the options
for each subsequent token in decreasing probability order and cut it off once it
- reaches a particular probability specified by `top_p`. You should either alter
- `temperature` or `top_p`, but not both.
+ reaches a particular probability specified by `top_p`.
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
extra_headers: Send extra headers
@@ -926,18 +920,15 @@ def create(
Used to remove "long tail" low probability responses.
[Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
top_p: Use nucleus sampling.
In nucleus sampling, we compute the cumulative distribution over all the options
for each subsequent token in decreasing probability order and cut it off once it
- reaches a particular probability specified by `top_p`. You should either alter
- `temperature` or `top_p`, but not both.
+ reaches a particular probability specified by `top_p`.
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
extra_headers: Send extra headers
@@ -1809,18 +1800,15 @@ async def create(
Used to remove "long tail" low probability responses.
[Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
top_p: Use nucleus sampling.
In nucleus sampling, we compute the cumulative distribution over all the options
for each subsequent token in decreasing probability order and cut it off once it
- reaches a particular probability specified by `top_p`. You should either alter
- `temperature` or `top_p`, but not both.
+ reaches a particular probability specified by `top_p`.
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
extra_headers: Send extra headers
@@ -2091,18 +2079,15 @@ async def create(
Used to remove "long tail" low probability responses.
[Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
top_p: Use nucleus sampling.
In nucleus sampling, we compute the cumulative distribution over all the options
for each subsequent token in decreasing probability order and cut it off once it
- reaches a particular probability specified by `top_p`. You should either alter
- `temperature` or `top_p`, but not both.
+ reaches a particular probability specified by `top_p`.
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
extra_headers: Send extra headers
@@ -2373,18 +2358,15 @@ async def create(
Used to remove "long tail" low probability responses.
[Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
top_p: Use nucleus sampling.
In nucleus sampling, we compute the cumulative distribution over all the options
for each subsequent token in decreasing probability order and cut it off once it
- reaches a particular probability specified by `top_p`. You should either alter
- `temperature` or `top_p`, but not both.
+ reaches a particular probability specified by `top_p`.
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
extra_headers: Send extra headers
diff --git a/src/anthropic/types/anthropic_beta_param.py b/src/anthropic/types/anthropic_beta_param.py
index eb084e89..b54a7968 100644
--- a/src/anthropic/types/anthropic_beta_param.py
+++ b/src/anthropic/types/anthropic_beta_param.py
@@ -31,7 +31,7 @@
"skills-2025-10-02",
"fast-mode-2026-02-01",
"output-300k-2026-03-24",
- "advisor-tool-2026-03-01",
"user-profiles-2026-03-24",
+ "advisor-tool-2026-03-01",
],
]
diff --git a/src/anthropic/types/beta/__init__.py b/src/anthropic/types/beta/__init__.py
index c18c0fb2..cb192466 100644
--- a/src/anthropic/types/beta/__init__.py
+++ b/src/anthropic/types/beta/__init__.py
@@ -82,6 +82,7 @@
from .beta_text_citation_param import BetaTextCitationParam as BetaTextCitationParam
from .beta_thinking_capability import BetaThinkingCapability as BetaThinkingCapability
from .beta_user_location_param import BetaUserLocationParam as BetaUserLocationParam
+from .memory_store_list_params import MemoryStoreListParams as MemoryStoreListParams
from .user_profile_list_params import UserProfileListParams as UserProfileListParams
from .beta_advisor_result_block import BetaAdvisorResultBlock as BetaAdvisorResultBlock
from .beta_managed_agents_agent import BetaManagedAgentsAgent as BetaManagedAgentsAgent
@@ -104,6 +105,8 @@
from .beta_thinking_config_param import BetaThinkingConfigParam as BetaThinkingConfigParam
from .beta_tool_choice_any_param import BetaToolChoiceAnyParam as BetaToolChoiceAnyParam
from .beta_web_fetch_block_param import BetaWebFetchBlockParam as BetaWebFetchBlockParam
+from .memory_store_create_params import MemoryStoreCreateParams as MemoryStoreCreateParams
+from .memory_store_update_params import MemoryStoreUpdateParams as MemoryStoreUpdateParams
from .user_profile_create_params import UserProfileCreateParams as UserProfileCreateParams
from .user_profile_update_params import UserProfileUpdateParams as UserProfileUpdateParams
from .beta_base64_pdf_block_param import BetaBase64PDFBlockParam as BetaBase64PDFBlockParam
@@ -163,6 +166,7 @@
from .beta_environment_delete_response import BetaEnvironmentDeleteResponse as BetaEnvironmentDeleteResponse
from .beta_managed_agents_agent_params import BetaManagedAgentsAgentParams as BetaManagedAgentsAgentParams
from .beta_managed_agents_custom_skill import BetaManagedAgentsCustomSkill as BetaManagedAgentsCustomSkill
+from .beta_managed_agents_memory_store import BetaManagedAgentsMemoryStore as BetaManagedAgentsMemoryStore
from .beta_managed_agents_model_config import BetaManagedAgentsModelConfig as BetaManagedAgentsModelConfig
from .beta_managed_agents_skill_params import BetaManagedAgentsSkillParams as BetaManagedAgentsSkillParams
from .beta_server_tool_caller_20260120 import BetaServerToolCaller20260120 as BetaServerToolCaller20260120
@@ -283,6 +287,9 @@
from .beta_managed_agents_cache_creation_usage import (
BetaManagedAgentsCacheCreationUsage as BetaManagedAgentsCacheCreationUsage,
)
+from .beta_managed_agents_deleted_memory_store import (
+ BetaManagedAgentsDeletedMemoryStore as BetaManagedAgentsDeletedMemoryStore,
+)
from .beta_managed_agents_file_resource_params import (
BetaManagedAgentsFileResourceParams as BetaManagedAgentsFileResourceParams,
)
@@ -415,6 +422,9 @@
from .beta_managed_agents_mcp_toolset_default_config import (
BetaManagedAgentsMCPToolsetDefaultConfig as BetaManagedAgentsMCPToolsetDefaultConfig,
)
+from .beta_managed_agents_memory_store_resource_param import (
+ BetaManagedAgentsMemoryStoreResourceParam as BetaManagedAgentsMemoryStoreResourceParam,
+)
from .beta_tool_search_tool_search_result_block_param import (
BetaToolSearchToolSearchResultBlockParam as BetaToolSearchToolSearchResultBlockParam,
)
diff --git a/src/anthropic/types/beta/beta_managed_agents_deleted_memory_store.py b/src/anthropic/types/beta/beta_managed_agents_deleted_memory_store.py
new file mode 100644
index 00000000..03e81c63
--- /dev/null
+++ b/src/anthropic/types/beta/beta_managed_agents_deleted_memory_store.py
@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["BetaManagedAgentsDeletedMemoryStore"]
+
+
+class BetaManagedAgentsDeletedMemoryStore(BaseModel):
+ id: str
+
+ type: Literal["memory_store_deleted"]
diff --git a/src/anthropic/types/beta/beta_managed_agents_memory_store.py b/src/anthropic/types/beta/beta_managed_agents_memory_store.py
new file mode 100644
index 00000000..0e3338a3
--- /dev/null
+++ b/src/anthropic/types/beta/beta_managed_agents_memory_store.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["BetaManagedAgentsMemoryStore"]
+
+
+class BetaManagedAgentsMemoryStore(BaseModel):
+ id: str
+
+ created_at: datetime
+ """A timestamp in RFC 3339 format"""
+
+ name: str
+
+ type: Literal["memory_store"]
+
+ updated_at: datetime
+ """A timestamp in RFC 3339 format"""
+
+ archived_at: Optional[datetime] = None
+ """A timestamp in RFC 3339 format"""
+
+ description: Optional[str] = None
+
+ metadata: Optional[Dict[str, str]] = None
diff --git a/src/anthropic/types/beta/beta_managed_agents_memory_store_resource_param.py b/src/anthropic/types/beta/beta_managed_agents_memory_store_resource_param.py
new file mode 100644
index 00000000..31170e63
--- /dev/null
+++ b/src/anthropic/types/beta/beta_managed_agents_memory_store_resource_param.py
@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["BetaManagedAgentsMemoryStoreResourceParam"]
+
+
+class BetaManagedAgentsMemoryStoreResourceParam(TypedDict, total=False):
+ """Parameters for attaching a memory store to an agent session."""
+
+ memory_store_id: Required[str]
+ """The memory store ID (memstore\\__...).
+
+ Must belong to the caller's organization and workspace.
+ """
+
+ type: Required[Literal["memory_store"]]
+
+ access: Optional[Literal["read_write", "read_only"]]
+ """Access mode for an attached memory store."""
+
+ instructions: Optional[str]
+ """Per-attachment guidance for the agent on how to use this store.
+
+ Rendered into the memory section of the system prompt. Max 4096 chars.
+ """
diff --git a/src/anthropic/types/beta/memory_store_create_params.py b/src/anthropic/types/beta/memory_store_create_params.py
new file mode 100644
index 00000000..e95e325f
--- /dev/null
+++ b/src/anthropic/types/beta/memory_store_create_params.py
@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, List
+from typing_extensions import Required, Annotated, TypedDict
+
+from ..._utils import PropertyInfo
+from ..anthropic_beta_param import AnthropicBetaParam
+
+__all__ = ["MemoryStoreCreateParams"]
+
+
+class MemoryStoreCreateParams(TypedDict, total=False):
+ name: Required[str]
+
+ description: str
+
+ metadata: Dict[str, str]
+
+ betas: Annotated[List[AnthropicBetaParam], PropertyInfo(alias="anthropic-beta")]
+ """Optional header to specify the beta version(s) you want to use."""
diff --git a/src/anthropic/types/beta/memory_store_list_params.py b/src/anthropic/types/beta/memory_store_list_params.py
new file mode 100644
index 00000000..c546bbc9
--- /dev/null
+++ b/src/anthropic/types/beta/memory_store_list_params.py
@@ -0,0 +1,32 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Union
+from datetime import datetime
+from typing_extensions import Annotated, TypedDict
+
+from ..._utils import PropertyInfo
+from ..anthropic_beta_param import AnthropicBetaParam
+
+__all__ = ["MemoryStoreListParams"]
+
+
+class MemoryStoreListParams(TypedDict, total=False):
+ created_at_gte: Annotated[Union[str, datetime], PropertyInfo(alias="created_at[gte]", format="iso8601")]
+ """Return stores created at or after this time (inclusive)."""
+
+ created_at_lte: Annotated[Union[str, datetime], PropertyInfo(alias="created_at[lte]", format="iso8601")]
+ """Return stores created at or before this time (inclusive)."""
+
+ include_archived: bool
+ """Query parameter for include_archived"""
+
+ limit: int
+ """Query parameter for limit"""
+
+ page: str
+ """Query parameter for page"""
+
+ betas: Annotated[List[AnthropicBetaParam], PropertyInfo(alias="anthropic-beta")]
+ """Optional header to specify the beta version(s) you want to use."""
diff --git a/src/anthropic/types/beta/memory_store_update_params.py b/src/anthropic/types/beta/memory_store_update_params.py
new file mode 100644
index 00000000..43ba4076
--- /dev/null
+++ b/src/anthropic/types/beta/memory_store_update_params.py
@@ -0,0 +1,28 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, List, Optional
+from typing_extensions import Annotated, TypedDict
+
+from ..._utils import PropertyInfo
+from ..anthropic_beta_param import AnthropicBetaParam
+
+__all__ = ["MemoryStoreUpdateParams"]
+
+
+class MemoryStoreUpdateParams(TypedDict, total=False):
+ description: Optional[str]
+
+ metadata: Optional[Dict[str, Optional[str]]]
+ """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.
+ """
+
+ name: Optional[str]
+
+ betas: Annotated[List[AnthropicBetaParam], PropertyInfo(alias="anthropic-beta")]
+ """Optional header to specify the beta version(s) you want to use."""
diff --git a/src/anthropic/types/beta/memory_stores/__init__.py b/src/anthropic/types/beta/memory_stores/__init__.py
new file mode 100644
index 00000000..536a7693
--- /dev/null
+++ b/src/anthropic/types/beta/memory_stores/__init__.py
@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .memory_list_params import MemoryListParams as MemoryListParams
+from .memory_create_params import MemoryCreateParams as MemoryCreateParams
+from .memory_delete_params import MemoryDeleteParams as MemoryDeleteParams
+from .memory_update_params import MemoryUpdateParams as MemoryUpdateParams
+from .memory_retrieve_params import MemoryRetrieveParams as MemoryRetrieveParams
+from .beta_managed_agents_actor import BetaManagedAgentsActor as BetaManagedAgentsActor
+from .beta_managed_agents_memory import BetaManagedAgentsMemory as BetaManagedAgentsMemory
+from .memory_version_list_params import MemoryVersionListParams as MemoryVersionListParams
+from .beta_managed_agents_api_actor import BetaManagedAgentsAPIActor as BetaManagedAgentsAPIActor
+from .beta_managed_agents_user_actor import BetaManagedAgentsUserActor as BetaManagedAgentsUserActor
+from .memory_version_retrieve_params import MemoryVersionRetrieveParams as MemoryVersionRetrieveParams
+from .beta_managed_agents_memory_view import BetaManagedAgentsMemoryView as BetaManagedAgentsMemoryView
+from .beta_managed_agents_memory_prefix import BetaManagedAgentsMemoryPrefix as BetaManagedAgentsMemoryPrefix
+from .beta_managed_agents_session_actor import BetaManagedAgentsSessionActor as BetaManagedAgentsSessionActor
+from .beta_managed_agents_deleted_memory import BetaManagedAgentsDeletedMemory as BetaManagedAgentsDeletedMemory
+from .beta_managed_agents_memory_version import BetaManagedAgentsMemoryVersion as BetaManagedAgentsMemoryVersion
+from .beta_managed_agents_memory_list_item import BetaManagedAgentsMemoryListItem as BetaManagedAgentsMemoryListItem
+from .beta_managed_agents_precondition_param import (
+ BetaManagedAgentsPreconditionParam as BetaManagedAgentsPreconditionParam,
+)
+from .beta_managed_agents_memory_version_operation import (
+ BetaManagedAgentsMemoryVersionOperation as BetaManagedAgentsMemoryVersionOperation,
+)
diff --git a/src/anthropic/types/beta/memory_stores/beta_managed_agents_actor.py b/src/anthropic/types/beta/memory_stores/beta_managed_agents_actor.py
new file mode 100644
index 00000000..06edaa7e
--- /dev/null
+++ b/src/anthropic/types/beta/memory_stores/beta_managed_agents_actor.py
@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Annotated, TypeAlias
+
+from ...._utils import PropertyInfo
+from .beta_managed_agents_api_actor import BetaManagedAgentsAPIActor
+from .beta_managed_agents_user_actor import BetaManagedAgentsUserActor
+from .beta_managed_agents_session_actor import BetaManagedAgentsSessionActor
+
+__all__ = ["BetaManagedAgentsActor"]
+
+BetaManagedAgentsActor: TypeAlias = Annotated[
+ Union[BetaManagedAgentsSessionActor, BetaManagedAgentsAPIActor, BetaManagedAgentsUserActor],
+ PropertyInfo(discriminator="type"),
+]
diff --git a/src/anthropic/types/beta/memory_stores/beta_managed_agents_api_actor.py b/src/anthropic/types/beta/memory_stores/beta_managed_agents_api_actor.py
new file mode 100644
index 00000000..5b0b17e5
--- /dev/null
+++ b/src/anthropic/types/beta/memory_stores/beta_managed_agents_api_actor.py
@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+
+__all__ = ["BetaManagedAgentsAPIActor"]
+
+
+class BetaManagedAgentsAPIActor(BaseModel):
+ api_key_id: str
+
+ type: Literal["api_actor"]
diff --git a/src/anthropic/types/beta/memory_stores/beta_managed_agents_deleted_memory.py b/src/anthropic/types/beta/memory_stores/beta_managed_agents_deleted_memory.py
new file mode 100644
index 00000000..8d56a703
--- /dev/null
+++ b/src/anthropic/types/beta/memory_stores/beta_managed_agents_deleted_memory.py
@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+
+__all__ = ["BetaManagedAgentsDeletedMemory"]
+
+
+class BetaManagedAgentsDeletedMemory(BaseModel):
+ id: str
+
+ type: Literal["memory_deleted"]
diff --git a/src/anthropic/types/beta/memory_stores/beta_managed_agents_memory.py b/src/anthropic/types/beta/memory_stores/beta_managed_agents_memory.py
new file mode 100644
index 00000000..c36955ef
--- /dev/null
+++ b/src/anthropic/types/beta/memory_stores/beta_managed_agents_memory.py
@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+
+__all__ = ["BetaManagedAgentsMemory"]
+
+
+class BetaManagedAgentsMemory(BaseModel):
+ id: str
+
+ content_sha256: str
+
+ content_size_bytes: int
+
+ created_at: datetime
+ """A timestamp in RFC 3339 format"""
+
+ memory_store_id: str
+
+ memory_version_id: str
+
+ path: str
+
+ type: Literal["memory"]
+
+ updated_at: datetime
+ """A timestamp in RFC 3339 format"""
+
+ content: Optional[str] = None
diff --git a/src/anthropic/types/beta/memory_stores/beta_managed_agents_memory_list_item.py b/src/anthropic/types/beta/memory_stores/beta_managed_agents_memory_list_item.py
new file mode 100644
index 00000000..eb849ec0
--- /dev/null
+++ b/src/anthropic/types/beta/memory_stores/beta_managed_agents_memory_list_item.py
@@ -0,0 +1,14 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Annotated, TypeAlias
+
+from ...._utils import PropertyInfo
+from .beta_managed_agents_memory import BetaManagedAgentsMemory
+from .beta_managed_agents_memory_prefix import BetaManagedAgentsMemoryPrefix
+
+__all__ = ["BetaManagedAgentsMemoryListItem"]
+
+BetaManagedAgentsMemoryListItem: TypeAlias = Annotated[
+ Union[BetaManagedAgentsMemory, BetaManagedAgentsMemoryPrefix], PropertyInfo(discriminator="type")
+]
diff --git a/src/anthropic/types/beta/memory_stores/beta_managed_agents_memory_prefix.py b/src/anthropic/types/beta/memory_stores/beta_managed_agents_memory_prefix.py
new file mode 100644
index 00000000..e160e5ef
--- /dev/null
+++ b/src/anthropic/types/beta/memory_stores/beta_managed_agents_memory_prefix.py
@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+
+__all__ = ["BetaManagedAgentsMemoryPrefix"]
+
+
+class BetaManagedAgentsMemoryPrefix(BaseModel):
+ path: str
+
+ type: Literal["memory_prefix"]
diff --git a/src/anthropic/types/beta/memory_stores/beta_managed_agents_memory_version.py b/src/anthropic/types/beta/memory_stores/beta_managed_agents_memory_version.py
new file mode 100644
index 00000000..c6539c43
--- /dev/null
+++ b/src/anthropic/types/beta/memory_stores/beta_managed_agents_memory_version.py
@@ -0,0 +1,42 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+from .beta_managed_agents_actor import BetaManagedAgentsActor
+from .beta_managed_agents_memory_version_operation import BetaManagedAgentsMemoryVersionOperation
+
+__all__ = ["BetaManagedAgentsMemoryVersion"]
+
+
+class BetaManagedAgentsMemoryVersion(BaseModel):
+ id: str
+
+ created_at: datetime
+ """A timestamp in RFC 3339 format"""
+
+ memory_id: str
+
+ memory_store_id: str
+
+ operation: BetaManagedAgentsMemoryVersionOperation
+ """MemoryVersionOperation enum"""
+
+ type: Literal["memory_version"]
+
+ content: Optional[str] = None
+
+ content_sha256: Optional[str] = None
+
+ content_size_bytes: Optional[int] = None
+
+ created_by: Optional[BetaManagedAgentsActor] = None
+
+ path: Optional[str] = None
+
+ redacted_at: Optional[datetime] = None
+ """A timestamp in RFC 3339 format"""
+
+ redacted_by: Optional[BetaManagedAgentsActor] = None
diff --git a/src/anthropic/types/beta/memory_stores/beta_managed_agents_memory_version_operation.py b/src/anthropic/types/beta/memory_stores/beta_managed_agents_memory_version_operation.py
new file mode 100644
index 00000000..611b136c
--- /dev/null
+++ b/src/anthropic/types/beta/memory_stores/beta_managed_agents_memory_version_operation.py
@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal, TypeAlias
+
+__all__ = ["BetaManagedAgentsMemoryVersionOperation"]
+
+BetaManagedAgentsMemoryVersionOperation: TypeAlias = Literal["created", "modified", "deleted"]
diff --git a/src/anthropic/types/beta/memory_stores/beta_managed_agents_memory_view.py b/src/anthropic/types/beta/memory_stores/beta_managed_agents_memory_view.py
new file mode 100644
index 00000000..b869ebdc
--- /dev/null
+++ b/src/anthropic/types/beta/memory_stores/beta_managed_agents_memory_view.py
@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal, TypeAlias
+
+__all__ = ["BetaManagedAgentsMemoryView"]
+
+BetaManagedAgentsMemoryView: TypeAlias = Literal["basic", "full"]
diff --git a/src/anthropic/types/beta/memory_stores/beta_managed_agents_precondition_param.py b/src/anthropic/types/beta/memory_stores/beta_managed_agents_precondition_param.py
new file mode 100644
index 00000000..2b38bec1
--- /dev/null
+++ b/src/anthropic/types/beta/memory_stores/beta_managed_agents_precondition_param.py
@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["BetaManagedAgentsPreconditionParam"]
+
+
+class BetaManagedAgentsPreconditionParam(TypedDict, total=False):
+ type: Required[Literal["content_sha256"]]
+
+ content_sha256: str
diff --git a/src/anthropic/types/beta/memory_stores/beta_managed_agents_session_actor.py b/src/anthropic/types/beta/memory_stores/beta_managed_agents_session_actor.py
new file mode 100644
index 00000000..45839671
--- /dev/null
+++ b/src/anthropic/types/beta/memory_stores/beta_managed_agents_session_actor.py
@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+
+__all__ = ["BetaManagedAgentsSessionActor"]
+
+
+class BetaManagedAgentsSessionActor(BaseModel):
+ session_id: str
+
+ type: Literal["session_actor"]
diff --git a/src/anthropic/types/beta/memory_stores/beta_managed_agents_user_actor.py b/src/anthropic/types/beta/memory_stores/beta_managed_agents_user_actor.py
new file mode 100644
index 00000000..6730a28e
--- /dev/null
+++ b/src/anthropic/types/beta/memory_stores/beta_managed_agents_user_actor.py
@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+
+__all__ = ["BetaManagedAgentsUserActor"]
+
+
+class BetaManagedAgentsUserActor(BaseModel):
+ type: Literal["user_actor"]
+
+ user_id: str
diff --git a/src/anthropic/types/beta/memory_stores/memory_create_params.py b/src/anthropic/types/beta/memory_stores/memory_create_params.py
new file mode 100644
index 00000000..093784d0
--- /dev/null
+++ b/src/anthropic/types/beta/memory_stores/memory_create_params.py
@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Optional
+from typing_extensions import Required, Annotated, TypedDict
+
+from ...._utils import PropertyInfo
+from ...anthropic_beta_param import AnthropicBetaParam
+from .beta_managed_agents_memory_view import BetaManagedAgentsMemoryView
+
+__all__ = ["MemoryCreateParams"]
+
+
+class MemoryCreateParams(TypedDict, total=False):
+ content: Required[Optional[str]]
+
+ path: Required[str]
+
+ view: BetaManagedAgentsMemoryView
+ """Query parameter for view"""
+
+ betas: Annotated[List[AnthropicBetaParam], PropertyInfo(alias="anthropic-beta")]
+ """Optional header to specify the beta version(s) you want to use."""
diff --git a/src/anthropic/types/beta/memory_stores/memory_delete_params.py b/src/anthropic/types/beta/memory_stores/memory_delete_params.py
new file mode 100644
index 00000000..fdf5f320
--- /dev/null
+++ b/src/anthropic/types/beta/memory_stores/memory_delete_params.py
@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Required, Annotated, TypedDict
+
+from ...._utils import PropertyInfo
+from ...anthropic_beta_param import AnthropicBetaParam
+
+__all__ = ["MemoryDeleteParams"]
+
+
+class MemoryDeleteParams(TypedDict, total=False):
+ memory_store_id: Required[str]
+
+ expected_content_sha256: str
+ """Query parameter for expected_content_sha256"""
+
+ betas: Annotated[List[AnthropicBetaParam], PropertyInfo(alias="anthropic-beta")]
+ """Optional header to specify the beta version(s) you want to use."""
diff --git a/src/anthropic/types/beta/memory_stores/memory_list_params.py b/src/anthropic/types/beta/memory_stores/memory_list_params.py
new file mode 100644
index 00000000..39c7650c
--- /dev/null
+++ b/src/anthropic/types/beta/memory_stores/memory_list_params.py
@@ -0,0 +1,42 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Literal, Annotated, TypedDict
+
+from ...._utils import PropertyInfo
+from ...anthropic_beta_param import AnthropicBetaParam
+from .beta_managed_agents_memory_view import BetaManagedAgentsMemoryView
+
+__all__ = ["MemoryListParams"]
+
+
+class MemoryListParams(TypedDict, total=False):
+ depth: int
+ """Query parameter for depth"""
+
+ limit: int
+ """Query parameter for limit"""
+
+ order: Literal["asc", "desc"]
+ """Query parameter for order"""
+
+ order_by: str
+ """Query parameter for order_by"""
+
+ page: str
+ """Query parameter for page"""
+
+ path_prefix: str
+ """
+ Optional path prefix filter (raw string-prefix match; include a trailing slash
+ for directory-scoped lists). This value appears in request URLs. Do not include
+ secrets or personally identifiable information.
+ """
+
+ view: BetaManagedAgentsMemoryView
+ """Query parameter for view"""
+
+ betas: Annotated[List[AnthropicBetaParam], PropertyInfo(alias="anthropic-beta")]
+ """Optional header to specify the beta version(s) you want to use."""
diff --git a/src/anthropic/types/beta/memory_stores/memory_retrieve_params.py b/src/anthropic/types/beta/memory_stores/memory_retrieve_params.py
new file mode 100644
index 00000000..5408384b
--- /dev/null
+++ b/src/anthropic/types/beta/memory_stores/memory_retrieve_params.py
@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Required, Annotated, TypedDict
+
+from ...._utils import PropertyInfo
+from ...anthropic_beta_param import AnthropicBetaParam
+from .beta_managed_agents_memory_view import BetaManagedAgentsMemoryView
+
+__all__ = ["MemoryRetrieveParams"]
+
+
+class MemoryRetrieveParams(TypedDict, total=False):
+ memory_store_id: Required[str]
+
+ view: BetaManagedAgentsMemoryView
+ """Query parameter for view"""
+
+ betas: Annotated[List[AnthropicBetaParam], PropertyInfo(alias="anthropic-beta")]
+ """Optional header to specify the beta version(s) you want to use."""
diff --git a/src/anthropic/types/beta/memory_stores/memory_update_params.py b/src/anthropic/types/beta/memory_stores/memory_update_params.py
new file mode 100644
index 00000000..ec2a4183
--- /dev/null
+++ b/src/anthropic/types/beta/memory_stores/memory_update_params.py
@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Optional
+from typing_extensions import Required, Annotated, TypedDict
+
+from ...._utils import PropertyInfo
+from ...anthropic_beta_param import AnthropicBetaParam
+from .beta_managed_agents_memory_view import BetaManagedAgentsMemoryView
+from .beta_managed_agents_precondition_param import BetaManagedAgentsPreconditionParam
+
+__all__ = ["MemoryUpdateParams"]
+
+
+class MemoryUpdateParams(TypedDict, total=False):
+ memory_store_id: Required[str]
+
+ view: BetaManagedAgentsMemoryView
+ """Query parameter for view"""
+
+ content: Optional[str]
+
+ path: Optional[str]
+
+ precondition: BetaManagedAgentsPreconditionParam
+
+ betas: Annotated[List[AnthropicBetaParam], PropertyInfo(alias="anthropic-beta")]
+ """Optional header to specify the beta version(s) you want to use."""
diff --git a/src/anthropic/types/beta/memory_stores/memory_version_list_params.py b/src/anthropic/types/beta/memory_stores/memory_version_list_params.py
new file mode 100644
index 00000000..dbcb6f45
--- /dev/null
+++ b/src/anthropic/types/beta/memory_stores/memory_version_list_params.py
@@ -0,0 +1,46 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Union
+from datetime import datetime
+from typing_extensions import Annotated, TypedDict
+
+from ...._utils import PropertyInfo
+from ...anthropic_beta_param import AnthropicBetaParam
+from .beta_managed_agents_memory_view import BetaManagedAgentsMemoryView
+from .beta_managed_agents_memory_version_operation import BetaManagedAgentsMemoryVersionOperation
+
+__all__ = ["MemoryVersionListParams"]
+
+
+class MemoryVersionListParams(TypedDict, total=False):
+ api_key_id: str
+ """Query parameter for api_key_id"""
+
+ created_at_gte: Annotated[Union[str, datetime], PropertyInfo(alias="created_at[gte]", format="iso8601")]
+ """Return versions created at or after this time (inclusive)."""
+
+ created_at_lte: Annotated[Union[str, datetime], PropertyInfo(alias="created_at[lte]", format="iso8601")]
+ """Return versions created at or before this time (inclusive)."""
+
+ limit: int
+ """Query parameter for limit"""
+
+ memory_id: str
+ """Query parameter for memory_id"""
+
+ operation: BetaManagedAgentsMemoryVersionOperation
+ """Query parameter for operation"""
+
+ page: str
+ """Query parameter for page"""
+
+ session_id: str
+ """Query parameter for session_id"""
+
+ view: BetaManagedAgentsMemoryView
+ """Query parameter for view"""
+
+ betas: Annotated[List[AnthropicBetaParam], PropertyInfo(alias="anthropic-beta")]
+ """Optional header to specify the beta version(s) you want to use."""
diff --git a/src/anthropic/types/beta/memory_stores/memory_version_retrieve_params.py b/src/anthropic/types/beta/memory_stores/memory_version_retrieve_params.py
new file mode 100644
index 00000000..0eb20891
--- /dev/null
+++ b/src/anthropic/types/beta/memory_stores/memory_version_retrieve_params.py
@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Required, Annotated, TypedDict
+
+from ...._utils import PropertyInfo
+from ...anthropic_beta_param import AnthropicBetaParam
+from .beta_managed_agents_memory_view import BetaManagedAgentsMemoryView
+
+__all__ = ["MemoryVersionRetrieveParams"]
+
+
+class MemoryVersionRetrieveParams(TypedDict, total=False):
+ memory_store_id: Required[str]
+
+ view: BetaManagedAgentsMemoryView
+ """Query parameter for view"""
+
+ betas: Annotated[List[AnthropicBetaParam], PropertyInfo(alias="anthropic-beta")]
+ """Optional header to specify the beta version(s) you want to use."""
diff --git a/src/anthropic/types/beta/message_create_params.py b/src/anthropic/types/beta/message_create_params.py
index 5dbad14f..419e921b 100644
--- a/src/anthropic/types/beta/message_create_params.py
+++ b/src/anthropic/types/beta/message_create_params.py
@@ -308,8 +308,7 @@ class MessageCreateParamsBase(TypedDict, total=False):
Used to remove "long tail" low probability responses.
[Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
"""
top_p: float
@@ -317,11 +316,9 @@ class MessageCreateParamsBase(TypedDict, total=False):
In nucleus sampling, we compute the cumulative distribution over all the options
for each subsequent token in decreasing probability order and cut it off once it
- reaches a particular probability specified by `top_p`. You should either alter
- `temperature` or `top_p`, but not both.
+ reaches a particular probability specified by `top_p`.
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
"""
user_profile_id: Optional[str]
diff --git a/src/anthropic/types/beta/messages/batch_create_params.py b/src/anthropic/types/beta/messages/batch_create_params.py
index 9fcd90fb..a24181f4 100644
--- a/src/anthropic/types/beta/messages/batch_create_params.py
+++ b/src/anthropic/types/beta/messages/batch_create_params.py
@@ -2,7 +2,7 @@
from __future__ import annotations
-from typing import List, Iterable
+from typing import List, Iterable, Optional
from typing_extensions import Required, Annotated, TypedDict
from ...._utils import PropertyInfo
@@ -24,6 +24,13 @@ class BatchCreateParams(TypedDict, total=False):
+ user_profile_id: Optional[str]
+ """The user profile ID to attribute this request to.
+
+ Use when acting on behalf of a party other than your organization.
+ """
+
+
class Request(TypedDict, total=False):
custom_id: Required[str]
"""Developer-provided ID created for each request in a Message Batch.
diff --git a/src/anthropic/types/beta/session_create_params.py b/src/anthropic/types/beta/session_create_params.py
index b334be61..4156a5b3 100644
--- a/src/anthropic/types/beta/session_create_params.py
+++ b/src/anthropic/types/beta/session_create_params.py
@@ -10,6 +10,7 @@
from ..anthropic_beta_param import AnthropicBetaParam
from .beta_managed_agents_agent_params import BetaManagedAgentsAgentParams
from .beta_managed_agents_file_resource_params import BetaManagedAgentsFileResourceParams
+from .beta_managed_agents_memory_store_resource_param import BetaManagedAgentsMemoryStoreResourceParam
from .beta_managed_agents_github_repository_resource_params import BetaManagedAgentsGitHubRepositoryResourceParams
__all__ = ["SessionCreateParams", "Agent", "Resource"]
@@ -47,4 +48,8 @@ class SessionCreateParams(TypedDict, total=False):
Agent: TypeAlias = Union[str, BetaManagedAgentsAgentParams]
-Resource: TypeAlias = Union[BetaManagedAgentsGitHubRepositoryResourceParams, BetaManagedAgentsFileResourceParams]
+Resource: TypeAlias = Union[
+ BetaManagedAgentsGitHubRepositoryResourceParams,
+ BetaManagedAgentsFileResourceParams,
+ BetaManagedAgentsMemoryStoreResourceParam,
+]
diff --git a/src/anthropic/types/beta/sessions/__init__.py b/src/anthropic/types/beta/sessions/__init__.py
index 47de3d4f..2fe6257d 100644
--- a/src/anthropic/types/beta/sessions/__init__.py
+++ b/src/anthropic/types/beta/sessions/__init__.py
@@ -57,6 +57,9 @@
from .beta_managed_agents_user_interrupt_event import (
BetaManagedAgentsUserInterruptEvent as BetaManagedAgentsUserInterruptEvent,
)
+from .beta_managed_agents_memory_store_resource import (
+ BetaManagedAgentsMemoryStoreResource as BetaManagedAgentsMemoryStoreResource,
+)
from .beta_managed_agents_retry_status_retrying import (
BetaManagedAgentsRetryStatusRetrying as BetaManagedAgentsRetryStatusRetrying,
)
diff --git a/src/anthropic/types/beta/sessions/beta_managed_agents_memory_store_resource.py b/src/anthropic/types/beta/sessions/beta_managed_agents_memory_store_resource.py
new file mode 100644
index 00000000..8740d6e1
--- /dev/null
+++ b/src/anthropic/types/beta/sessions/beta_managed_agents_memory_store_resource.py
@@ -0,0 +1,48 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+
+__all__ = ["BetaManagedAgentsMemoryStoreResource"]
+
+
+class BetaManagedAgentsMemoryStoreResource(BaseModel):
+ """A memory store attached to an agent session."""
+
+ memory_store_id: str
+ """The memory store ID (memstore\\__...).
+
+ Must belong to the caller's organization and workspace.
+ """
+
+ type: Literal["memory_store"]
+
+ access: Optional[Literal["read_write", "read_only"]] = None
+ """Access mode for an attached memory store."""
+
+ description: Optional[str] = None
+ """Description of the memory store, snapshotted at attach time.
+
+ Rendered into the agent's system prompt. Empty string when the store has no
+ description.
+ """
+
+ instructions: Optional[str] = None
+ """Per-attachment guidance for the agent on how to use this store.
+
+ Rendered into the memory section of the system prompt. Max 4096 chars.
+ """
+
+ mount_path: Optional[str] = None
+ """Filesystem path where the store is mounted in the session container, e.g.
+
+ /mnt/memory/user-preferences. Derived from the store's name. Output-only.
+ """
+
+ name: Optional[str] = None
+ """Display name of the memory store, snapshotted at attach time.
+
+ Later edits to the store's name do not propagate to this resource.
+ """
diff --git a/src/anthropic/types/beta/sessions/beta_managed_agents_session_resource.py b/src/anthropic/types/beta/sessions/beta_managed_agents_session_resource.py
index 93d9fce7..47f26cfd 100644
--- a/src/anthropic/types/beta/sessions/beta_managed_agents_session_resource.py
+++ b/src/anthropic/types/beta/sessions/beta_managed_agents_session_resource.py
@@ -5,10 +5,14 @@
from ...._utils import PropertyInfo
from .beta_managed_agents_file_resource import BetaManagedAgentsFileResource
+from .beta_managed_agents_memory_store_resource import BetaManagedAgentsMemoryStoreResource
from .beta_managed_agents_github_repository_resource import BetaManagedAgentsGitHubRepositoryResource
__all__ = ["BetaManagedAgentsSessionResource"]
BetaManagedAgentsSessionResource: TypeAlias = Annotated[
- Union[BetaManagedAgentsGitHubRepositoryResource, BetaManagedAgentsFileResource], PropertyInfo(discriminator="type")
+ Union[
+ BetaManagedAgentsGitHubRepositoryResource, BetaManagedAgentsFileResource, BetaManagedAgentsMemoryStoreResource
+ ],
+ PropertyInfo(discriminator="type"),
]
diff --git a/src/anthropic/types/beta/sessions/resource_retrieve_response.py b/src/anthropic/types/beta/sessions/resource_retrieve_response.py
index d65417ec..a956ba17 100644
--- a/src/anthropic/types/beta/sessions/resource_retrieve_response.py
+++ b/src/anthropic/types/beta/sessions/resource_retrieve_response.py
@@ -5,10 +5,14 @@
from ...._utils import PropertyInfo
from .beta_managed_agents_file_resource import BetaManagedAgentsFileResource
+from .beta_managed_agents_memory_store_resource import BetaManagedAgentsMemoryStoreResource
from .beta_managed_agents_github_repository_resource import BetaManagedAgentsGitHubRepositoryResource
__all__ = ["ResourceRetrieveResponse"]
ResourceRetrieveResponse: TypeAlias = Annotated[
- Union[BetaManagedAgentsGitHubRepositoryResource, BetaManagedAgentsFileResource], PropertyInfo(discriminator="type")
+ Union[
+ BetaManagedAgentsGitHubRepositoryResource, BetaManagedAgentsFileResource, BetaManagedAgentsMemoryStoreResource
+ ],
+ PropertyInfo(discriminator="type"),
]
diff --git a/src/anthropic/types/beta/sessions/resource_update_response.py b/src/anthropic/types/beta/sessions/resource_update_response.py
index 0981e9ec..d20f0a34 100644
--- a/src/anthropic/types/beta/sessions/resource_update_response.py
+++ b/src/anthropic/types/beta/sessions/resource_update_response.py
@@ -5,10 +5,14 @@
from ...._utils import PropertyInfo
from .beta_managed_agents_file_resource import BetaManagedAgentsFileResource
+from .beta_managed_agents_memory_store_resource import BetaManagedAgentsMemoryStoreResource
from .beta_managed_agents_github_repository_resource import BetaManagedAgentsGitHubRepositoryResource
__all__ = ["ResourceUpdateResponse"]
ResourceUpdateResponse: TypeAlias = Annotated[
- Union[BetaManagedAgentsGitHubRepositoryResource, BetaManagedAgentsFileResource], PropertyInfo(discriminator="type")
+ Union[
+ BetaManagedAgentsGitHubRepositoryResource, BetaManagedAgentsFileResource, BetaManagedAgentsMemoryStoreResource
+ ],
+ PropertyInfo(discriminator="type"),
]
diff --git a/src/anthropic/types/completion_create_params.py b/src/anthropic/types/completion_create_params.py
index 5164682d..9f337e8f 100644
--- a/src/anthropic/types/completion_create_params.py
+++ b/src/anthropic/types/completion_create_params.py
@@ -81,8 +81,7 @@ class CompletionCreateParamsBase(TypedDict, total=False):
Used to remove "long tail" low probability responses.
[Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
"""
top_p: float
@@ -90,11 +89,9 @@ class CompletionCreateParamsBase(TypedDict, total=False):
In nucleus sampling, we compute the cumulative distribution over all the options
for each subsequent token in decreasing probability order and cut it off once it
- reaches a particular probability specified by `top_p`. You should either alter
- `temperature` or `top_p`, but not both.
+ reaches a particular probability specified by `top_p`.
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
"""
betas: Annotated[List[AnthropicBetaParam], PropertyInfo(alias="anthropic-beta")]
diff --git a/src/anthropic/types/message_create_params.py b/src/anthropic/types/message_create_params.py
index 464a0ae4..09c79491 100644
--- a/src/anthropic/types/message_create_params.py
+++ b/src/anthropic/types/message_create_params.py
@@ -281,8 +281,7 @@ class MessageCreateParamsBase(TypedDict, total=False):
Used to remove "long tail" low probability responses.
[Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
"""
top_p: float
@@ -290,11 +289,9 @@ class MessageCreateParamsBase(TypedDict, total=False):
In nucleus sampling, we compute the cumulative distribution over all the options
for each subsequent token in decreasing probability order and cut it off once it
- reaches a particular probability specified by `top_p`. You should either alter
- `temperature` or `top_p`, but not both.
+ reaches a particular probability specified by `top_p`.
- Recommended for advanced use cases only. You usually only need to use
- `temperature`.
+ Recommended for advanced use cases only.
"""
diff --git a/src/anthropic/types/messages/batch_create_params.py b/src/anthropic/types/messages/batch_create_params.py
index e60c74f1..880136e2 100644
--- a/src/anthropic/types/messages/batch_create_params.py
+++ b/src/anthropic/types/messages/batch_create_params.py
@@ -18,6 +18,7 @@ class BatchCreateParams(TypedDict, total=False):
"""
+
class Request(TypedDict, total=False):
custom_id: Required[str]
"""Developer-provided ID created for each request in a Message Batch.
diff --git a/tests/api_resources/beta/memory_stores/__init__.py b/tests/api_resources/beta/memory_stores/__init__.py
new file mode 100644
index 00000000..fd8019a9
--- /dev/null
+++ b/tests/api_resources/beta/memory_stores/__init__.py
@@ -0,0 +1 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
diff --git a/tests/api_resources/beta/memory_stores/test_memories.py b/tests/api_resources/beta/memory_stores/test_memories.py
new file mode 100644
index 00000000..8d86a1d0
--- /dev/null
+++ b/tests/api_resources/beta/memory_stores/test_memories.py
@@ -0,0 +1,619 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+from typing import Any, cast
+
+import pytest
+
+from anthropic import Anthropic, AsyncAnthropic
+from tests.utils import assert_matches_type
+from anthropic.pagination import SyncPageCursor, AsyncPageCursor
+from anthropic.types.beta.memory_stores import (
+ BetaManagedAgentsMemory,
+ BetaManagedAgentsDeletedMemory,
+ BetaManagedAgentsMemoryListItem,
+)
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestMemories:
+ parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+ @parametrize
+ def test_method_create(self, client: Anthropic) -> None:
+ memory = client.beta.memory_stores.memories.create(
+ memory_store_id="memory_store_id",
+ content="content",
+ path="xx",
+ )
+ assert_matches_type(BetaManagedAgentsMemory, memory, path=["response"])
+
+ @parametrize
+ def test_method_create_with_all_params(self, client: Anthropic) -> None:
+ memory = client.beta.memory_stores.memories.create(
+ memory_store_id="memory_store_id",
+ content="content",
+ path="xx",
+ view="basic",
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(BetaManagedAgentsMemory, memory, path=["response"])
+
+ @parametrize
+ def test_raw_response_create(self, client: Anthropic) -> None:
+ response = client.beta.memory_stores.memories.with_raw_response.create(
+ memory_store_id="memory_store_id",
+ content="content",
+ path="xx",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory = response.parse()
+ assert_matches_type(BetaManagedAgentsMemory, memory, path=["response"])
+
+ @parametrize
+ def test_streaming_response_create(self, client: Anthropic) -> None:
+ with client.beta.memory_stores.memories.with_streaming_response.create(
+ memory_store_id="memory_store_id",
+ content="content",
+ path="xx",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory = response.parse()
+ assert_matches_type(BetaManagedAgentsMemory, memory, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @parametrize
+ def test_path_params_create(self, client: Anthropic) -> None:
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_store_id` but received ''"):
+ client.beta.memory_stores.memories.with_raw_response.create(
+ memory_store_id="",
+ content="content",
+ path="xx",
+ )
+
+ @parametrize
+ def test_method_retrieve(self, client: Anthropic) -> None:
+ memory = client.beta.memory_stores.memories.retrieve(
+ memory_id="memory_id",
+ memory_store_id="memory_store_id",
+ )
+ assert_matches_type(BetaManagedAgentsMemory, memory, path=["response"])
+
+ @parametrize
+ def test_method_retrieve_with_all_params(self, client: Anthropic) -> None:
+ memory = client.beta.memory_stores.memories.retrieve(
+ memory_id="memory_id",
+ memory_store_id="memory_store_id",
+ view="basic",
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(BetaManagedAgentsMemory, memory, path=["response"])
+
+ @parametrize
+ def test_raw_response_retrieve(self, client: Anthropic) -> None:
+ response = client.beta.memory_stores.memories.with_raw_response.retrieve(
+ memory_id="memory_id",
+ memory_store_id="memory_store_id",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory = response.parse()
+ assert_matches_type(BetaManagedAgentsMemory, memory, path=["response"])
+
+ @parametrize
+ def test_streaming_response_retrieve(self, client: Anthropic) -> None:
+ with client.beta.memory_stores.memories.with_streaming_response.retrieve(
+ memory_id="memory_id",
+ memory_store_id="memory_store_id",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory = response.parse()
+ assert_matches_type(BetaManagedAgentsMemory, memory, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @parametrize
+ def test_path_params_retrieve(self, client: Anthropic) -> None:
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_store_id` but received ''"):
+ client.beta.memory_stores.memories.with_raw_response.retrieve(
+ memory_id="memory_id",
+ memory_store_id="",
+ )
+
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_id` but received ''"):
+ client.beta.memory_stores.memories.with_raw_response.retrieve(
+ memory_id="",
+ memory_store_id="memory_store_id",
+ )
+
+ @parametrize
+ def test_method_update(self, client: Anthropic) -> None:
+ memory = client.beta.memory_stores.memories.update(
+ memory_id="memory_id",
+ memory_store_id="memory_store_id",
+ )
+ assert_matches_type(BetaManagedAgentsMemory, memory, path=["response"])
+
+ @parametrize
+ def test_method_update_with_all_params(self, client: Anthropic) -> None:
+ memory = client.beta.memory_stores.memories.update(
+ memory_id="memory_id",
+ memory_store_id="memory_store_id",
+ view="basic",
+ content="content",
+ path="xx",
+ precondition={
+ "type": "content_sha256",
+ "content_sha256": "content_sha256",
+ },
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(BetaManagedAgentsMemory, memory, path=["response"])
+
+ @parametrize
+ def test_raw_response_update(self, client: Anthropic) -> None:
+ response = client.beta.memory_stores.memories.with_raw_response.update(
+ memory_id="memory_id",
+ memory_store_id="memory_store_id",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory = response.parse()
+ assert_matches_type(BetaManagedAgentsMemory, memory, path=["response"])
+
+ @parametrize
+ def test_streaming_response_update(self, client: Anthropic) -> None:
+ with client.beta.memory_stores.memories.with_streaming_response.update(
+ memory_id="memory_id",
+ memory_store_id="memory_store_id",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory = response.parse()
+ assert_matches_type(BetaManagedAgentsMemory, memory, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @parametrize
+ def test_path_params_update(self, client: Anthropic) -> None:
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_store_id` but received ''"):
+ client.beta.memory_stores.memories.with_raw_response.update(
+ memory_id="memory_id",
+ memory_store_id="",
+ )
+
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_id` but received ''"):
+ client.beta.memory_stores.memories.with_raw_response.update(
+ memory_id="",
+ memory_store_id="memory_store_id",
+ )
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ def test_method_list(self, client: Anthropic) -> None:
+ memory = client.beta.memory_stores.memories.list(
+ memory_store_id="memory_store_id",
+ )
+ assert_matches_type(SyncPageCursor[BetaManagedAgentsMemoryListItem], memory, path=["response"])
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ def test_method_list_with_all_params(self, client: Anthropic) -> None:
+ memory = client.beta.memory_stores.memories.list(
+ memory_store_id="memory_store_id",
+ depth=0,
+ limit=0,
+ order="asc",
+ order_by="order_by",
+ page="page",
+ path_prefix="path_prefix",
+ view="basic",
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(SyncPageCursor[BetaManagedAgentsMemoryListItem], memory, path=["response"])
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ def test_raw_response_list(self, client: Anthropic) -> None:
+ response = client.beta.memory_stores.memories.with_raw_response.list(
+ memory_store_id="memory_store_id",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory = response.parse()
+ assert_matches_type(SyncPageCursor[BetaManagedAgentsMemoryListItem], memory, path=["response"])
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ def test_streaming_response_list(self, client: Anthropic) -> None:
+ with client.beta.memory_stores.memories.with_streaming_response.list(
+ memory_store_id="memory_store_id",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory = response.parse()
+ assert_matches_type(SyncPageCursor[BetaManagedAgentsMemoryListItem], memory, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ def test_path_params_list(self, client: Anthropic) -> None:
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_store_id` but received ''"):
+ client.beta.memory_stores.memories.with_raw_response.list(
+ memory_store_id="",
+ )
+
+ @parametrize
+ def test_method_delete(self, client: Anthropic) -> None:
+ memory = client.beta.memory_stores.memories.delete(
+ memory_id="memory_id",
+ memory_store_id="memory_store_id",
+ )
+ assert_matches_type(BetaManagedAgentsDeletedMemory, memory, path=["response"])
+
+ @parametrize
+ def test_method_delete_with_all_params(self, client: Anthropic) -> None:
+ memory = client.beta.memory_stores.memories.delete(
+ memory_id="memory_id",
+ memory_store_id="memory_store_id",
+ expected_content_sha256="expected_content_sha256",
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(BetaManagedAgentsDeletedMemory, memory, path=["response"])
+
+ @parametrize
+ def test_raw_response_delete(self, client: Anthropic) -> None:
+ response = client.beta.memory_stores.memories.with_raw_response.delete(
+ memory_id="memory_id",
+ memory_store_id="memory_store_id",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory = response.parse()
+ assert_matches_type(BetaManagedAgentsDeletedMemory, memory, path=["response"])
+
+ @parametrize
+ def test_streaming_response_delete(self, client: Anthropic) -> None:
+ with client.beta.memory_stores.memories.with_streaming_response.delete(
+ memory_id="memory_id",
+ memory_store_id="memory_store_id",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory = response.parse()
+ assert_matches_type(BetaManagedAgentsDeletedMemory, memory, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @parametrize
+ def test_path_params_delete(self, client: Anthropic) -> None:
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_store_id` but received ''"):
+ client.beta.memory_stores.memories.with_raw_response.delete(
+ memory_id="memory_id",
+ memory_store_id="",
+ )
+
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_id` but received ''"):
+ client.beta.memory_stores.memories.with_raw_response.delete(
+ memory_id="",
+ memory_store_id="memory_store_id",
+ )
+
+
+class TestAsyncMemories:
+ parametrize = pytest.mark.parametrize(
+ "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+ )
+
+ @parametrize
+ async def test_method_create(self, async_client: AsyncAnthropic) -> None:
+ memory = await async_client.beta.memory_stores.memories.create(
+ memory_store_id="memory_store_id",
+ content="content",
+ path="xx",
+ )
+ assert_matches_type(BetaManagedAgentsMemory, memory, path=["response"])
+
+ @parametrize
+ async def test_method_create_with_all_params(self, async_client: AsyncAnthropic) -> None:
+ memory = await async_client.beta.memory_stores.memories.create(
+ memory_store_id="memory_store_id",
+ content="content",
+ path="xx",
+ view="basic",
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(BetaManagedAgentsMemory, memory, path=["response"])
+
+ @parametrize
+ async def test_raw_response_create(self, async_client: AsyncAnthropic) -> None:
+ response = await async_client.beta.memory_stores.memories.with_raw_response.create(
+ memory_store_id="memory_store_id",
+ content="content",
+ path="xx",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory = response.parse()
+ assert_matches_type(BetaManagedAgentsMemory, memory, path=["response"])
+
+ @parametrize
+ async def test_streaming_response_create(self, async_client: AsyncAnthropic) -> None:
+ async with async_client.beta.memory_stores.memories.with_streaming_response.create(
+ memory_store_id="memory_store_id",
+ content="content",
+ path="xx",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory = await response.parse()
+ assert_matches_type(BetaManagedAgentsMemory, memory, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @parametrize
+ async def test_path_params_create(self, async_client: AsyncAnthropic) -> None:
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_store_id` but received ''"):
+ await async_client.beta.memory_stores.memories.with_raw_response.create(
+ memory_store_id="",
+ content="content",
+ path="xx",
+ )
+
+ @parametrize
+ async def test_method_retrieve(self, async_client: AsyncAnthropic) -> None:
+ memory = await async_client.beta.memory_stores.memories.retrieve(
+ memory_id="memory_id",
+ memory_store_id="memory_store_id",
+ )
+ assert_matches_type(BetaManagedAgentsMemory, memory, path=["response"])
+
+ @parametrize
+ async def test_method_retrieve_with_all_params(self, async_client: AsyncAnthropic) -> None:
+ memory = await async_client.beta.memory_stores.memories.retrieve(
+ memory_id="memory_id",
+ memory_store_id="memory_store_id",
+ view="basic",
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(BetaManagedAgentsMemory, memory, path=["response"])
+
+ @parametrize
+ async def test_raw_response_retrieve(self, async_client: AsyncAnthropic) -> None:
+ response = await async_client.beta.memory_stores.memories.with_raw_response.retrieve(
+ memory_id="memory_id",
+ memory_store_id="memory_store_id",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory = response.parse()
+ assert_matches_type(BetaManagedAgentsMemory, memory, path=["response"])
+
+ @parametrize
+ async def test_streaming_response_retrieve(self, async_client: AsyncAnthropic) -> None:
+ async with async_client.beta.memory_stores.memories.with_streaming_response.retrieve(
+ memory_id="memory_id",
+ memory_store_id="memory_store_id",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory = await response.parse()
+ assert_matches_type(BetaManagedAgentsMemory, memory, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @parametrize
+ async def test_path_params_retrieve(self, async_client: AsyncAnthropic) -> None:
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_store_id` but received ''"):
+ await async_client.beta.memory_stores.memories.with_raw_response.retrieve(
+ memory_id="memory_id",
+ memory_store_id="",
+ )
+
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_id` but received ''"):
+ await async_client.beta.memory_stores.memories.with_raw_response.retrieve(
+ memory_id="",
+ memory_store_id="memory_store_id",
+ )
+
+ @parametrize
+ async def test_method_update(self, async_client: AsyncAnthropic) -> None:
+ memory = await async_client.beta.memory_stores.memories.update(
+ memory_id="memory_id",
+ memory_store_id="memory_store_id",
+ )
+ assert_matches_type(BetaManagedAgentsMemory, memory, path=["response"])
+
+ @parametrize
+ async def test_method_update_with_all_params(self, async_client: AsyncAnthropic) -> None:
+ memory = await async_client.beta.memory_stores.memories.update(
+ memory_id="memory_id",
+ memory_store_id="memory_store_id",
+ view="basic",
+ content="content",
+ path="xx",
+ precondition={
+ "type": "content_sha256",
+ "content_sha256": "content_sha256",
+ },
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(BetaManagedAgentsMemory, memory, path=["response"])
+
+ @parametrize
+ async def test_raw_response_update(self, async_client: AsyncAnthropic) -> None:
+ response = await async_client.beta.memory_stores.memories.with_raw_response.update(
+ memory_id="memory_id",
+ memory_store_id="memory_store_id",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory = response.parse()
+ assert_matches_type(BetaManagedAgentsMemory, memory, path=["response"])
+
+ @parametrize
+ async def test_streaming_response_update(self, async_client: AsyncAnthropic) -> None:
+ async with async_client.beta.memory_stores.memories.with_streaming_response.update(
+ memory_id="memory_id",
+ memory_store_id="memory_store_id",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory = await response.parse()
+ assert_matches_type(BetaManagedAgentsMemory, memory, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @parametrize
+ async def test_path_params_update(self, async_client: AsyncAnthropic) -> None:
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_store_id` but received ''"):
+ await async_client.beta.memory_stores.memories.with_raw_response.update(
+ memory_id="memory_id",
+ memory_store_id="",
+ )
+
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_id` but received ''"):
+ await async_client.beta.memory_stores.memories.with_raw_response.update(
+ memory_id="",
+ memory_store_id="memory_store_id",
+ )
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ async def test_method_list(self, async_client: AsyncAnthropic) -> None:
+ memory = await async_client.beta.memory_stores.memories.list(
+ memory_store_id="memory_store_id",
+ )
+ assert_matches_type(AsyncPageCursor[BetaManagedAgentsMemoryListItem], memory, path=["response"])
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ async def test_method_list_with_all_params(self, async_client: AsyncAnthropic) -> None:
+ memory = await async_client.beta.memory_stores.memories.list(
+ memory_store_id="memory_store_id",
+ depth=0,
+ limit=0,
+ order="asc",
+ order_by="order_by",
+ page="page",
+ path_prefix="path_prefix",
+ view="basic",
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(AsyncPageCursor[BetaManagedAgentsMemoryListItem], memory, path=["response"])
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ async def test_raw_response_list(self, async_client: AsyncAnthropic) -> None:
+ response = await async_client.beta.memory_stores.memories.with_raw_response.list(
+ memory_store_id="memory_store_id",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory = response.parse()
+ assert_matches_type(AsyncPageCursor[BetaManagedAgentsMemoryListItem], memory, path=["response"])
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ async def test_streaming_response_list(self, async_client: AsyncAnthropic) -> None:
+ async with async_client.beta.memory_stores.memories.with_streaming_response.list(
+ memory_store_id="memory_store_id",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory = await response.parse()
+ assert_matches_type(AsyncPageCursor[BetaManagedAgentsMemoryListItem], memory, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ async def test_path_params_list(self, async_client: AsyncAnthropic) -> None:
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_store_id` but received ''"):
+ await async_client.beta.memory_stores.memories.with_raw_response.list(
+ memory_store_id="",
+ )
+
+ @parametrize
+ async def test_method_delete(self, async_client: AsyncAnthropic) -> None:
+ memory = await async_client.beta.memory_stores.memories.delete(
+ memory_id="memory_id",
+ memory_store_id="memory_store_id",
+ )
+ assert_matches_type(BetaManagedAgentsDeletedMemory, memory, path=["response"])
+
+ @parametrize
+ async def test_method_delete_with_all_params(self, async_client: AsyncAnthropic) -> None:
+ memory = await async_client.beta.memory_stores.memories.delete(
+ memory_id="memory_id",
+ memory_store_id="memory_store_id",
+ expected_content_sha256="expected_content_sha256",
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(BetaManagedAgentsDeletedMemory, memory, path=["response"])
+
+ @parametrize
+ async def test_raw_response_delete(self, async_client: AsyncAnthropic) -> None:
+ response = await async_client.beta.memory_stores.memories.with_raw_response.delete(
+ memory_id="memory_id",
+ memory_store_id="memory_store_id",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory = response.parse()
+ assert_matches_type(BetaManagedAgentsDeletedMemory, memory, path=["response"])
+
+ @parametrize
+ async def test_streaming_response_delete(self, async_client: AsyncAnthropic) -> None:
+ async with async_client.beta.memory_stores.memories.with_streaming_response.delete(
+ memory_id="memory_id",
+ memory_store_id="memory_store_id",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory = await response.parse()
+ assert_matches_type(BetaManagedAgentsDeletedMemory, memory, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @parametrize
+ async def test_path_params_delete(self, async_client: AsyncAnthropic) -> None:
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_store_id` but received ''"):
+ await async_client.beta.memory_stores.memories.with_raw_response.delete(
+ memory_id="memory_id",
+ memory_store_id="",
+ )
+
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_id` but received ''"):
+ await async_client.beta.memory_stores.memories.with_raw_response.delete(
+ memory_id="",
+ memory_store_id="memory_store_id",
+ )
diff --git a/tests/api_resources/beta/memory_stores/test_memory_versions.py b/tests/api_resources/beta/memory_stores/test_memory_versions.py
new file mode 100644
index 00000000..f4318584
--- /dev/null
+++ b/tests/api_resources/beta/memory_stores/test_memory_versions.py
@@ -0,0 +1,378 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+from typing import Any, cast
+
+import pytest
+
+from anthropic import Anthropic, AsyncAnthropic
+from tests.utils import assert_matches_type
+from anthropic._utils import parse_datetime
+from anthropic.pagination import SyncPageCursor, AsyncPageCursor
+from anthropic.types.beta.memory_stores import (
+ BetaManagedAgentsMemoryVersion,
+)
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestMemoryVersions:
+ parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+ @parametrize
+ def test_method_retrieve(self, client: Anthropic) -> None:
+ memory_version = client.beta.memory_stores.memory_versions.retrieve(
+ memory_version_id="memory_version_id",
+ memory_store_id="memory_store_id",
+ )
+ assert_matches_type(BetaManagedAgentsMemoryVersion, memory_version, path=["response"])
+
+ @parametrize
+ def test_method_retrieve_with_all_params(self, client: Anthropic) -> None:
+ memory_version = client.beta.memory_stores.memory_versions.retrieve(
+ memory_version_id="memory_version_id",
+ memory_store_id="memory_store_id",
+ view="basic",
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(BetaManagedAgentsMemoryVersion, memory_version, path=["response"])
+
+ @parametrize
+ def test_raw_response_retrieve(self, client: Anthropic) -> None:
+ response = client.beta.memory_stores.memory_versions.with_raw_response.retrieve(
+ memory_version_id="memory_version_id",
+ memory_store_id="memory_store_id",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory_version = response.parse()
+ assert_matches_type(BetaManagedAgentsMemoryVersion, memory_version, path=["response"])
+
+ @parametrize
+ def test_streaming_response_retrieve(self, client: Anthropic) -> None:
+ with client.beta.memory_stores.memory_versions.with_streaming_response.retrieve(
+ memory_version_id="memory_version_id",
+ memory_store_id="memory_store_id",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory_version = response.parse()
+ assert_matches_type(BetaManagedAgentsMemoryVersion, memory_version, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @parametrize
+ def test_path_params_retrieve(self, client: Anthropic) -> None:
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_store_id` but received ''"):
+ client.beta.memory_stores.memory_versions.with_raw_response.retrieve(
+ memory_version_id="memory_version_id",
+ memory_store_id="",
+ )
+
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_version_id` but received ''"):
+ client.beta.memory_stores.memory_versions.with_raw_response.retrieve(
+ memory_version_id="",
+ memory_store_id="memory_store_id",
+ )
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ def test_method_list(self, client: Anthropic) -> None:
+ memory_version = client.beta.memory_stores.memory_versions.list(
+ memory_store_id="memory_store_id",
+ )
+ assert_matches_type(SyncPageCursor[BetaManagedAgentsMemoryVersion], memory_version, path=["response"])
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ def test_method_list_with_all_params(self, client: Anthropic) -> None:
+ memory_version = client.beta.memory_stores.memory_versions.list(
+ memory_store_id="memory_store_id",
+ api_key_id="api_key_id",
+ created_at_gte=parse_datetime("2019-12-27T18:11:19.117Z"),
+ created_at_lte=parse_datetime("2019-12-27T18:11:19.117Z"),
+ limit=0,
+ memory_id="memory_id",
+ operation="created",
+ page="page",
+ session_id="session_id",
+ view="basic",
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(SyncPageCursor[BetaManagedAgentsMemoryVersion], memory_version, path=["response"])
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ def test_raw_response_list(self, client: Anthropic) -> None:
+ response = client.beta.memory_stores.memory_versions.with_raw_response.list(
+ memory_store_id="memory_store_id",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory_version = response.parse()
+ assert_matches_type(SyncPageCursor[BetaManagedAgentsMemoryVersion], memory_version, path=["response"])
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ def test_streaming_response_list(self, client: Anthropic) -> None:
+ with client.beta.memory_stores.memory_versions.with_streaming_response.list(
+ memory_store_id="memory_store_id",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory_version = response.parse()
+ assert_matches_type(SyncPageCursor[BetaManagedAgentsMemoryVersion], memory_version, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ def test_path_params_list(self, client: Anthropic) -> None:
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_store_id` but received ''"):
+ client.beta.memory_stores.memory_versions.with_raw_response.list(
+ memory_store_id="",
+ )
+
+ @parametrize
+ def test_method_redact(self, client: Anthropic) -> None:
+ memory_version = client.beta.memory_stores.memory_versions.redact(
+ memory_version_id="memory_version_id",
+ memory_store_id="memory_store_id",
+ )
+ assert_matches_type(BetaManagedAgentsMemoryVersion, memory_version, path=["response"])
+
+ @parametrize
+ def test_method_redact_with_all_params(self, client: Anthropic) -> None:
+ memory_version = client.beta.memory_stores.memory_versions.redact(
+ memory_version_id="memory_version_id",
+ memory_store_id="memory_store_id",
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(BetaManagedAgentsMemoryVersion, memory_version, path=["response"])
+
+ @parametrize
+ def test_raw_response_redact(self, client: Anthropic) -> None:
+ response = client.beta.memory_stores.memory_versions.with_raw_response.redact(
+ memory_version_id="memory_version_id",
+ memory_store_id="memory_store_id",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory_version = response.parse()
+ assert_matches_type(BetaManagedAgentsMemoryVersion, memory_version, path=["response"])
+
+ @parametrize
+ def test_streaming_response_redact(self, client: Anthropic) -> None:
+ with client.beta.memory_stores.memory_versions.with_streaming_response.redact(
+ memory_version_id="memory_version_id",
+ memory_store_id="memory_store_id",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory_version = response.parse()
+ assert_matches_type(BetaManagedAgentsMemoryVersion, memory_version, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @parametrize
+ def test_path_params_redact(self, client: Anthropic) -> None:
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_store_id` but received ''"):
+ client.beta.memory_stores.memory_versions.with_raw_response.redact(
+ memory_version_id="memory_version_id",
+ memory_store_id="",
+ )
+
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_version_id` but received ''"):
+ client.beta.memory_stores.memory_versions.with_raw_response.redact(
+ memory_version_id="",
+ memory_store_id="memory_store_id",
+ )
+
+
+class TestAsyncMemoryVersions:
+ parametrize = pytest.mark.parametrize(
+ "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+ )
+
+ @parametrize
+ async def test_method_retrieve(self, async_client: AsyncAnthropic) -> None:
+ memory_version = await async_client.beta.memory_stores.memory_versions.retrieve(
+ memory_version_id="memory_version_id",
+ memory_store_id="memory_store_id",
+ )
+ assert_matches_type(BetaManagedAgentsMemoryVersion, memory_version, path=["response"])
+
+ @parametrize
+ async def test_method_retrieve_with_all_params(self, async_client: AsyncAnthropic) -> None:
+ memory_version = await async_client.beta.memory_stores.memory_versions.retrieve(
+ memory_version_id="memory_version_id",
+ memory_store_id="memory_store_id",
+ view="basic",
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(BetaManagedAgentsMemoryVersion, memory_version, path=["response"])
+
+ @parametrize
+ async def test_raw_response_retrieve(self, async_client: AsyncAnthropic) -> None:
+ response = await async_client.beta.memory_stores.memory_versions.with_raw_response.retrieve(
+ memory_version_id="memory_version_id",
+ memory_store_id="memory_store_id",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory_version = response.parse()
+ assert_matches_type(BetaManagedAgentsMemoryVersion, memory_version, path=["response"])
+
+ @parametrize
+ async def test_streaming_response_retrieve(self, async_client: AsyncAnthropic) -> None:
+ async with async_client.beta.memory_stores.memory_versions.with_streaming_response.retrieve(
+ memory_version_id="memory_version_id",
+ memory_store_id="memory_store_id",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory_version = await response.parse()
+ assert_matches_type(BetaManagedAgentsMemoryVersion, memory_version, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @parametrize
+ async def test_path_params_retrieve(self, async_client: AsyncAnthropic) -> None:
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_store_id` but received ''"):
+ await async_client.beta.memory_stores.memory_versions.with_raw_response.retrieve(
+ memory_version_id="memory_version_id",
+ memory_store_id="",
+ )
+
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_version_id` but received ''"):
+ await async_client.beta.memory_stores.memory_versions.with_raw_response.retrieve(
+ memory_version_id="",
+ memory_store_id="memory_store_id",
+ )
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ async def test_method_list(self, async_client: AsyncAnthropic) -> None:
+ memory_version = await async_client.beta.memory_stores.memory_versions.list(
+ memory_store_id="memory_store_id",
+ )
+ assert_matches_type(AsyncPageCursor[BetaManagedAgentsMemoryVersion], memory_version, path=["response"])
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ async def test_method_list_with_all_params(self, async_client: AsyncAnthropic) -> None:
+ memory_version = await async_client.beta.memory_stores.memory_versions.list(
+ memory_store_id="memory_store_id",
+ api_key_id="api_key_id",
+ created_at_gte=parse_datetime("2019-12-27T18:11:19.117Z"),
+ created_at_lte=parse_datetime("2019-12-27T18:11:19.117Z"),
+ limit=0,
+ memory_id="memory_id",
+ operation="created",
+ page="page",
+ session_id="session_id",
+ view="basic",
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(AsyncPageCursor[BetaManagedAgentsMemoryVersion], memory_version, path=["response"])
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ async def test_raw_response_list(self, async_client: AsyncAnthropic) -> None:
+ response = await async_client.beta.memory_stores.memory_versions.with_raw_response.list(
+ memory_store_id="memory_store_id",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory_version = response.parse()
+ assert_matches_type(AsyncPageCursor[BetaManagedAgentsMemoryVersion], memory_version, path=["response"])
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ async def test_streaming_response_list(self, async_client: AsyncAnthropic) -> None:
+ async with async_client.beta.memory_stores.memory_versions.with_streaming_response.list(
+ memory_store_id="memory_store_id",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory_version = await response.parse()
+ assert_matches_type(AsyncPageCursor[BetaManagedAgentsMemoryVersion], memory_version, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ async def test_path_params_list(self, async_client: AsyncAnthropic) -> None:
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_store_id` but received ''"):
+ await async_client.beta.memory_stores.memory_versions.with_raw_response.list(
+ memory_store_id="",
+ )
+
+ @parametrize
+ async def test_method_redact(self, async_client: AsyncAnthropic) -> None:
+ memory_version = await async_client.beta.memory_stores.memory_versions.redact(
+ memory_version_id="memory_version_id",
+ memory_store_id="memory_store_id",
+ )
+ assert_matches_type(BetaManagedAgentsMemoryVersion, memory_version, path=["response"])
+
+ @parametrize
+ async def test_method_redact_with_all_params(self, async_client: AsyncAnthropic) -> None:
+ memory_version = await async_client.beta.memory_stores.memory_versions.redact(
+ memory_version_id="memory_version_id",
+ memory_store_id="memory_store_id",
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(BetaManagedAgentsMemoryVersion, memory_version, path=["response"])
+
+ @parametrize
+ async def test_raw_response_redact(self, async_client: AsyncAnthropic) -> None:
+ response = await async_client.beta.memory_stores.memory_versions.with_raw_response.redact(
+ memory_version_id="memory_version_id",
+ memory_store_id="memory_store_id",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory_version = response.parse()
+ assert_matches_type(BetaManagedAgentsMemoryVersion, memory_version, path=["response"])
+
+ @parametrize
+ async def test_streaming_response_redact(self, async_client: AsyncAnthropic) -> None:
+ async with async_client.beta.memory_stores.memory_versions.with_streaming_response.redact(
+ memory_version_id="memory_version_id",
+ memory_store_id="memory_store_id",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory_version = await response.parse()
+ assert_matches_type(BetaManagedAgentsMemoryVersion, memory_version, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @parametrize
+ async def test_path_params_redact(self, async_client: AsyncAnthropic) -> None:
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_store_id` but received ''"):
+ await async_client.beta.memory_stores.memory_versions.with_raw_response.redact(
+ memory_version_id="memory_version_id",
+ memory_store_id="",
+ )
+
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_version_id` but received ''"):
+ await async_client.beta.memory_stores.memory_versions.with_raw_response.redact(
+ memory_version_id="",
+ memory_store_id="memory_store_id",
+ )
diff --git a/tests/api_resources/beta/test_memory_stores.py b/tests/api_resources/beta/test_memory_stores.py
new file mode 100644
index 00000000..8ed9e9de
--- /dev/null
+++ b/tests/api_resources/beta/test_memory_stores.py
@@ -0,0 +1,567 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+from typing import Any, cast
+
+import pytest
+
+from anthropic import Anthropic, AsyncAnthropic
+from tests.utils import assert_matches_type
+from anthropic._utils import parse_datetime
+from anthropic.pagination import SyncPageCursor, AsyncPageCursor
+from anthropic.types.beta import (
+ BetaManagedAgentsMemoryStore,
+ BetaManagedAgentsDeletedMemoryStore,
+)
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestMemoryStores:
+ parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+ @parametrize
+ def test_method_create(self, client: Anthropic) -> None:
+ memory_store = client.beta.memory_stores.create(
+ name="x",
+ )
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ def test_method_create_with_all_params(self, client: Anthropic) -> None:
+ memory_store = client.beta.memory_stores.create(
+ name="x",
+ description="description",
+ metadata={"foo": "string"},
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ def test_raw_response_create(self, client: Anthropic) -> None:
+ response = client.beta.memory_stores.with_raw_response.create(
+ name="x",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory_store = response.parse()
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ def test_streaming_response_create(self, client: Anthropic) -> None:
+ with client.beta.memory_stores.with_streaming_response.create(
+ name="x",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory_store = response.parse()
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @parametrize
+ def test_method_retrieve(self, client: Anthropic) -> None:
+ memory_store = client.beta.memory_stores.retrieve(
+ memory_store_id="memory_store_id",
+ )
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ def test_method_retrieve_with_all_params(self, client: Anthropic) -> None:
+ memory_store = client.beta.memory_stores.retrieve(
+ memory_store_id="memory_store_id",
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ def test_raw_response_retrieve(self, client: Anthropic) -> None:
+ response = client.beta.memory_stores.with_raw_response.retrieve(
+ memory_store_id="memory_store_id",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory_store = response.parse()
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ def test_streaming_response_retrieve(self, client: Anthropic) -> None:
+ with client.beta.memory_stores.with_streaming_response.retrieve(
+ memory_store_id="memory_store_id",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory_store = response.parse()
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @parametrize
+ def test_path_params_retrieve(self, client: Anthropic) -> None:
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_store_id` but received ''"):
+ client.beta.memory_stores.with_raw_response.retrieve(
+ memory_store_id="",
+ )
+
+ @parametrize
+ def test_method_update(self, client: Anthropic) -> None:
+ memory_store = client.beta.memory_stores.update(
+ memory_store_id="memory_store_id",
+ )
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ def test_method_update_with_all_params(self, client: Anthropic) -> None:
+ memory_store = client.beta.memory_stores.update(
+ memory_store_id="memory_store_id",
+ description="description",
+ metadata={"foo": "string"},
+ name="x",
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ def test_raw_response_update(self, client: Anthropic) -> None:
+ response = client.beta.memory_stores.with_raw_response.update(
+ memory_store_id="memory_store_id",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory_store = response.parse()
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ def test_streaming_response_update(self, client: Anthropic) -> None:
+ with client.beta.memory_stores.with_streaming_response.update(
+ memory_store_id="memory_store_id",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory_store = response.parse()
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @parametrize
+ def test_path_params_update(self, client: Anthropic) -> None:
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_store_id` but received ''"):
+ client.beta.memory_stores.with_raw_response.update(
+ memory_store_id="",
+ )
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ def test_method_list(self, client: Anthropic) -> None:
+ memory_store = client.beta.memory_stores.list()
+ assert_matches_type(SyncPageCursor[BetaManagedAgentsMemoryStore], memory_store, path=["response"])
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ def test_method_list_with_all_params(self, client: Anthropic) -> None:
+ memory_store = client.beta.memory_stores.list(
+ created_at_gte=parse_datetime("2019-12-27T18:11:19.117Z"),
+ created_at_lte=parse_datetime("2019-12-27T18:11:19.117Z"),
+ include_archived=True,
+ limit=0,
+ page="page",
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(SyncPageCursor[BetaManagedAgentsMemoryStore], memory_store, path=["response"])
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ def test_raw_response_list(self, client: Anthropic) -> None:
+ response = client.beta.memory_stores.with_raw_response.list()
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory_store = response.parse()
+ assert_matches_type(SyncPageCursor[BetaManagedAgentsMemoryStore], memory_store, path=["response"])
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ def test_streaming_response_list(self, client: Anthropic) -> None:
+ with client.beta.memory_stores.with_streaming_response.list() as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory_store = response.parse()
+ assert_matches_type(SyncPageCursor[BetaManagedAgentsMemoryStore], memory_store, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @parametrize
+ def test_method_delete(self, client: Anthropic) -> None:
+ memory_store = client.beta.memory_stores.delete(
+ memory_store_id="memory_store_id",
+ )
+ assert_matches_type(BetaManagedAgentsDeletedMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ def test_method_delete_with_all_params(self, client: Anthropic) -> None:
+ memory_store = client.beta.memory_stores.delete(
+ memory_store_id="memory_store_id",
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(BetaManagedAgentsDeletedMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ def test_raw_response_delete(self, client: Anthropic) -> None:
+ response = client.beta.memory_stores.with_raw_response.delete(
+ memory_store_id="memory_store_id",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory_store = response.parse()
+ assert_matches_type(BetaManagedAgentsDeletedMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ def test_streaming_response_delete(self, client: Anthropic) -> None:
+ with client.beta.memory_stores.with_streaming_response.delete(
+ memory_store_id="memory_store_id",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory_store = response.parse()
+ assert_matches_type(BetaManagedAgentsDeletedMemoryStore, memory_store, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @parametrize
+ def test_path_params_delete(self, client: Anthropic) -> None:
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_store_id` but received ''"):
+ client.beta.memory_stores.with_raw_response.delete(
+ memory_store_id="",
+ )
+
+ @parametrize
+ def test_method_archive(self, client: Anthropic) -> None:
+ memory_store = client.beta.memory_stores.archive(
+ memory_store_id="memory_store_id",
+ )
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ def test_method_archive_with_all_params(self, client: Anthropic) -> None:
+ memory_store = client.beta.memory_stores.archive(
+ memory_store_id="memory_store_id",
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ def test_raw_response_archive(self, client: Anthropic) -> None:
+ response = client.beta.memory_stores.with_raw_response.archive(
+ memory_store_id="memory_store_id",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory_store = response.parse()
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ def test_streaming_response_archive(self, client: Anthropic) -> None:
+ with client.beta.memory_stores.with_streaming_response.archive(
+ memory_store_id="memory_store_id",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory_store = response.parse()
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @parametrize
+ def test_path_params_archive(self, client: Anthropic) -> None:
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_store_id` but received ''"):
+ client.beta.memory_stores.with_raw_response.archive(
+ memory_store_id="",
+ )
+
+
+class TestAsyncMemoryStores:
+ parametrize = pytest.mark.parametrize(
+ "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+ )
+
+ @parametrize
+ async def test_method_create(self, async_client: AsyncAnthropic) -> None:
+ memory_store = await async_client.beta.memory_stores.create(
+ name="x",
+ )
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ async def test_method_create_with_all_params(self, async_client: AsyncAnthropic) -> None:
+ memory_store = await async_client.beta.memory_stores.create(
+ name="x",
+ description="description",
+ metadata={"foo": "string"},
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ async def test_raw_response_create(self, async_client: AsyncAnthropic) -> None:
+ response = await async_client.beta.memory_stores.with_raw_response.create(
+ name="x",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory_store = response.parse()
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ async def test_streaming_response_create(self, async_client: AsyncAnthropic) -> None:
+ async with async_client.beta.memory_stores.with_streaming_response.create(
+ name="x",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory_store = await response.parse()
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @parametrize
+ async def test_method_retrieve(self, async_client: AsyncAnthropic) -> None:
+ memory_store = await async_client.beta.memory_stores.retrieve(
+ memory_store_id="memory_store_id",
+ )
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ async def test_method_retrieve_with_all_params(self, async_client: AsyncAnthropic) -> None:
+ memory_store = await async_client.beta.memory_stores.retrieve(
+ memory_store_id="memory_store_id",
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ async def test_raw_response_retrieve(self, async_client: AsyncAnthropic) -> None:
+ response = await async_client.beta.memory_stores.with_raw_response.retrieve(
+ memory_store_id="memory_store_id",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory_store = response.parse()
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ async def test_streaming_response_retrieve(self, async_client: AsyncAnthropic) -> None:
+ async with async_client.beta.memory_stores.with_streaming_response.retrieve(
+ memory_store_id="memory_store_id",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory_store = await response.parse()
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @parametrize
+ async def test_path_params_retrieve(self, async_client: AsyncAnthropic) -> None:
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_store_id` but received ''"):
+ await async_client.beta.memory_stores.with_raw_response.retrieve(
+ memory_store_id="",
+ )
+
+ @parametrize
+ async def test_method_update(self, async_client: AsyncAnthropic) -> None:
+ memory_store = await async_client.beta.memory_stores.update(
+ memory_store_id="memory_store_id",
+ )
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ async def test_method_update_with_all_params(self, async_client: AsyncAnthropic) -> None:
+ memory_store = await async_client.beta.memory_stores.update(
+ memory_store_id="memory_store_id",
+ description="description",
+ metadata={"foo": "string"},
+ name="x",
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ async def test_raw_response_update(self, async_client: AsyncAnthropic) -> None:
+ response = await async_client.beta.memory_stores.with_raw_response.update(
+ memory_store_id="memory_store_id",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory_store = response.parse()
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ async def test_streaming_response_update(self, async_client: AsyncAnthropic) -> None:
+ async with async_client.beta.memory_stores.with_streaming_response.update(
+ memory_store_id="memory_store_id",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory_store = await response.parse()
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @parametrize
+ async def test_path_params_update(self, async_client: AsyncAnthropic) -> None:
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_store_id` but received ''"):
+ await async_client.beta.memory_stores.with_raw_response.update(
+ memory_store_id="",
+ )
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ async def test_method_list(self, async_client: AsyncAnthropic) -> None:
+ memory_store = await async_client.beta.memory_stores.list()
+ assert_matches_type(AsyncPageCursor[BetaManagedAgentsMemoryStore], memory_store, path=["response"])
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ async def test_method_list_with_all_params(self, async_client: AsyncAnthropic) -> None:
+ memory_store = await async_client.beta.memory_stores.list(
+ created_at_gte=parse_datetime("2019-12-27T18:11:19.117Z"),
+ created_at_lte=parse_datetime("2019-12-27T18:11:19.117Z"),
+ include_archived=True,
+ limit=0,
+ page="page",
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(AsyncPageCursor[BetaManagedAgentsMemoryStore], memory_store, path=["response"])
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ async def test_raw_response_list(self, async_client: AsyncAnthropic) -> None:
+ response = await async_client.beta.memory_stores.with_raw_response.list()
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory_store = response.parse()
+ assert_matches_type(AsyncPageCursor[BetaManagedAgentsMemoryStore], memory_store, path=["response"])
+
+ @pytest.mark.skip(reason="buildURL drops path-level query params (SDK-4349)")
+ @parametrize
+ async def test_streaming_response_list(self, async_client: AsyncAnthropic) -> None:
+ async with async_client.beta.memory_stores.with_streaming_response.list() as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory_store = await response.parse()
+ assert_matches_type(AsyncPageCursor[BetaManagedAgentsMemoryStore], memory_store, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @parametrize
+ async def test_method_delete(self, async_client: AsyncAnthropic) -> None:
+ memory_store = await async_client.beta.memory_stores.delete(
+ memory_store_id="memory_store_id",
+ )
+ assert_matches_type(BetaManagedAgentsDeletedMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ async def test_method_delete_with_all_params(self, async_client: AsyncAnthropic) -> None:
+ memory_store = await async_client.beta.memory_stores.delete(
+ memory_store_id="memory_store_id",
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(BetaManagedAgentsDeletedMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ async def test_raw_response_delete(self, async_client: AsyncAnthropic) -> None:
+ response = await async_client.beta.memory_stores.with_raw_response.delete(
+ memory_store_id="memory_store_id",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory_store = response.parse()
+ assert_matches_type(BetaManagedAgentsDeletedMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ async def test_streaming_response_delete(self, async_client: AsyncAnthropic) -> None:
+ async with async_client.beta.memory_stores.with_streaming_response.delete(
+ memory_store_id="memory_store_id",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory_store = await response.parse()
+ assert_matches_type(BetaManagedAgentsDeletedMemoryStore, memory_store, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @parametrize
+ async def test_path_params_delete(self, async_client: AsyncAnthropic) -> None:
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_store_id` but received ''"):
+ await async_client.beta.memory_stores.with_raw_response.delete(
+ memory_store_id="",
+ )
+
+ @parametrize
+ async def test_method_archive(self, async_client: AsyncAnthropic) -> None:
+ memory_store = await async_client.beta.memory_stores.archive(
+ memory_store_id="memory_store_id",
+ )
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ async def test_method_archive_with_all_params(self, async_client: AsyncAnthropic) -> None:
+ memory_store = await async_client.beta.memory_stores.archive(
+ memory_store_id="memory_store_id",
+ betas=["message-batches-2024-09-24"],
+ )
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ async def test_raw_response_archive(self, async_client: AsyncAnthropic) -> None:
+ response = await async_client.beta.memory_stores.with_raw_response.archive(
+ memory_store_id="memory_store_id",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ memory_store = response.parse()
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ @parametrize
+ async def test_streaming_response_archive(self, async_client: AsyncAnthropic) -> None:
+ async with async_client.beta.memory_stores.with_streaming_response.archive(
+ memory_store_id="memory_store_id",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ memory_store = await response.parse()
+ assert_matches_type(BetaManagedAgentsMemoryStore, memory_store, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+ @parametrize
+ async def test_path_params_archive(self, async_client: AsyncAnthropic) -> None:
+ with pytest.raises(ValueError, match=r"Expected a non-empty value for `memory_store_id` but received ''"):
+ await async_client.beta.memory_stores.with_raw_response.archive(
+ memory_store_id="",
+ )
diff --git a/tests/api_resources/beta/test_messages.py b/tests/api_resources/beta/test_messages.py
index 621930fd..53048924 100644
--- a/tests/api_resources/beta/test_messages.py
+++ b/tests/api_resources/beta/test_messages.py
@@ -167,7 +167,7 @@ def test_method_create_with_all_params_overload_1(self, client: Anthropic) -> No
top_k=5,
top_p=0.7,
user_profile_id="user_profile_id",
- betas=["string"],
+ betas=["message-batches-2024-09-24"],
)
assert_matches_type(BetaMessage, message, path=["response"])
@@ -356,7 +356,7 @@ def test_method_create_with_all_params_overload_2(self, client: Anthropic) -> No
top_k=5,
top_p=0.7,
user_profile_id="user_profile_id",
- betas=["string"],
+ betas=["message-batches-2024-09-24"],
)
message_stream.response.close()
@@ -733,7 +733,7 @@ async def test_method_create_with_all_params_overload_1(self, async_client: Asyn
top_k=5,
top_p=0.7,
user_profile_id="user_profile_id",
- betas=["string"],
+ betas=["message-batches-2024-09-24"],
)
assert_matches_type(BetaMessage, message, path=["response"])
@@ -922,7 +922,7 @@ async def test_method_create_with_all_params_overload_2(self, async_client: Asyn
top_k=5,
top_p=0.7,
user_profile_id="user_profile_id",
- betas=["string"],
+ betas=["message-batches-2024-09-24"],
)
await message_stream.response.aclose()
diff --git a/tests/test_deepcopy.py b/tests/test_deepcopy.py
deleted file mode 100644
index edbbfb22..00000000
--- a/tests/test_deepcopy.py
+++ /dev/null
@@ -1,58 +0,0 @@
-from anthropic._utils import deepcopy_minimal
-
-
-def assert_different_identities(obj1: object, obj2: object) -> None:
- assert obj1 == obj2
- assert id(obj1) != id(obj2)
-
-
-def test_simple_dict() -> None:
- obj1 = {"foo": "bar"}
- obj2 = deepcopy_minimal(obj1)
- assert_different_identities(obj1, obj2)
-
-
-def test_nested_dict() -> None:
- obj1 = {"foo": {"bar": True}}
- obj2 = deepcopy_minimal(obj1)
- assert_different_identities(obj1, obj2)
- assert_different_identities(obj1["foo"], obj2["foo"])
-
-
-def test_complex_nested_dict() -> None:
- obj1 = {"foo": {"bar": [{"hello": "world"}]}}
- obj2 = deepcopy_minimal(obj1)
- assert_different_identities(obj1, obj2)
- assert_different_identities(obj1["foo"], obj2["foo"])
- assert_different_identities(obj1["foo"]["bar"], obj2["foo"]["bar"])
- assert_different_identities(obj1["foo"]["bar"][0], obj2["foo"]["bar"][0])
-
-
-def test_simple_list() -> None:
- obj1 = ["a", "b", "c"]
- obj2 = deepcopy_minimal(obj1)
- assert_different_identities(obj1, obj2)
-
-
-def test_nested_list() -> None:
- obj1 = ["a", [1, 2, 3]]
- obj2 = deepcopy_minimal(obj1)
- assert_different_identities(obj1, obj2)
- assert_different_identities(obj1[1], obj2[1])
-
-
-class MyObject: ...
-
-
-def test_ignores_other_types() -> None:
- # custom classes
- my_obj = MyObject()
- obj1 = {"foo": my_obj}
- obj2 = deepcopy_minimal(obj1)
- assert_different_identities(obj1, obj2)
- assert obj1["foo"] is my_obj
-
- # tuples
- obj3 = ("a", "b")
- obj4 = deepcopy_minimal(obj3)
- assert obj3 is obj4
diff --git a/tests/test_files.py b/tests/test_files.py
index 4b118fe0..fc571b25 100644
--- a/tests/test_files.py
+++ b/tests/test_files.py
@@ -4,7 +4,8 @@
import pytest
from dirty_equals import IsDict, IsList, IsBytes, IsTuple
-from anthropic._files import to_httpx_files, async_to_httpx_files
+from anthropic._files import to_httpx_files, deepcopy_with_paths, async_to_httpx_files
+from anthropic._utils import extract_files
readme_path = Path(__file__).parent.parent.joinpath("README.md")
@@ -49,3 +50,99 @@ def test_string_not_allowed() -> None:
"file": "foo", # type: ignore
}
)
+
+
+def assert_different_identities(obj1: object, obj2: object) -> None:
+ assert obj1 == obj2
+ assert obj1 is not obj2
+
+
+class TestDeepcopyWithPaths:
+ def test_copies_top_level_dict(self) -> None:
+ original = {"file": b"data", "other": "value"}
+ result = deepcopy_with_paths(original, [["file"]])
+ assert_different_identities(result, original)
+
+ def test_file_value_is_same_reference(self) -> None:
+ file_bytes = b"contents"
+ original = {"file": file_bytes}
+ result = deepcopy_with_paths(original, [["file"]])
+ assert_different_identities(result, original)
+ assert result["file"] is file_bytes
+
+ def test_list_popped_wholesale(self) -> None:
+ files = [b"f1", b"f2"]
+ original = {"files": files, "title": "t"}
+ result = deepcopy_with_paths(original, [["files", ""]])
+ assert_different_identities(result, original)
+ result_files = result["files"]
+ assert isinstance(result_files, list)
+ assert_different_identities(result_files, files)
+
+ def test_nested_array_path_copies_list_and_elements(self) -> None:
+ elem1 = {"file": b"f1", "extra": 1}
+ elem2 = {"file": b"f2", "extra": 2}
+ original = {"items": [elem1, elem2]}
+ result = deepcopy_with_paths(original, [["items", "", "file"]])
+ assert_different_identities(result, original)
+ result_items = result["items"]
+ assert isinstance(result_items, list)
+ assert_different_identities(result_items, original["items"])
+ assert_different_identities(result_items[0], elem1)
+ assert_different_identities(result_items[1], elem2)
+
+ def test_empty_paths_returns_same_object(self) -> None:
+ original = {"foo": "bar"}
+ result = deepcopy_with_paths(original, [])
+ assert result is original
+
+ def test_multiple_paths(self) -> None:
+ f1 = b"file1"
+ f2 = b"file2"
+ original = {"a": f1, "b": f2, "c": "unchanged"}
+ result = deepcopy_with_paths(original, [["a"], ["b"]])
+ assert_different_identities(result, original)
+ assert result["a"] is f1
+ assert result["b"] is f2
+ assert result["c"] is original["c"]
+
+ def test_extract_files_does_not_mutate_original_top_level(self) -> None:
+ file_bytes = b"contents"
+ original = {"file": file_bytes, "other": "value"}
+
+ copied = deepcopy_with_paths(original, [["file"]])
+ extracted = extract_files(copied, paths=[["file"]])
+
+ assert extracted == [("file", file_bytes)]
+ assert original == {"file": file_bytes, "other": "value"}
+ assert copied == {"other": "value"}
+
+ def test_extract_files_does_not_mutate_original_nested_array_path(self) -> None:
+ file1 = b"f1"
+ file2 = b"f2"
+ original = {
+ "items": [
+ {"file": file1, "extra": 1},
+ {"file": file2, "extra": 2},
+ ],
+ "title": "example",
+ }
+
+ copied = deepcopy_with_paths(original, [["items", "", "file"]])
+ extracted = extract_files(copied, paths=[["items", "", "file"]])
+
+ assert extracted == [("items[][file]", file1), ("items[][file]", file2)]
+ assert original == {
+ "items": [
+ {"file": file1, "extra": 1},
+ {"file": file2, "extra": 2},
+ ],
+ "title": "example",
+ }
+ assert copied == {
+ "items": [
+ {"extra": 1},
+ {"extra": 2},
+ ],
+ "title": "example",
+ }