anthropic 0.68.2__py3-none-any.whl → 0.70.0__py3-none-any.whl

anthropic/_version.py

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

anthropic/lib/streaming/_beta_messages.py

@@ -486,6 +486,7 @@ def accumulate_event(
         current_snapshot.stop_reason = event.delta.stop_reason
         current_snapshot.stop_sequence = event.delta.stop_sequence
         current_snapshot.usage.output_tokens = event.usage.output_tokens
+        current_snapshot.context_management = event.context_management
 
         # Update other usage fields if they exist in the event
         if event.usage.input_tokens is not None:

anthropic/lib/tools/__init__.py

@@ -2,19 +2,26 @@ from ._beta_runner import BetaToolRunner, BetaAsyncToolRunner, BetaStreamingTool
 from ._beta_functions import (
     BetaFunctionTool,
     BetaAsyncFunctionTool,
+    BetaBuiltinFunctionTool,
     BetaFunctionToolResultType,
+    BetaAsyncBuiltinFunctionTool,
     beta_tool,
     beta_async_tool,
 )
+from ._beta_builtin_memory_tool import BetaAbstractMemoryTool, BetaAsyncAbstractMemoryTool
 
 __all__ = [
     "beta_tool",
     "beta_async_tool",
     "BetaFunctionTool",
     "BetaAsyncFunctionTool",
+    "BetaBuiltinFunctionTool",
+    "BetaAsyncBuiltinFunctionTool",
     "BetaToolRunner",
     "BetaAsyncStreamingToolRunner",
     "BetaStreamingToolRunner",
     "BetaAsyncToolRunner",
     "BetaFunctionToolResultType",
+    "BetaAbstractMemoryTool",
+    "BetaAsyncAbstractMemoryTool",
 ]

anthropic/lib/tools/_beta_builtin_memory_tool.py

@@ -0,0 +1,245 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from typing import TYPE_CHECKING, Any, cast
+from typing_extensions import override, assert_never
+
+from ..._models import construct_type_unchecked
+from ...types.beta import (
+    BetaMemoryTool20250818Param,
+    BetaMemoryTool20250818Command,
+    BetaCacheControlEphemeralParam,
+    BetaMemoryTool20250818ViewCommand,
+    BetaMemoryTool20250818CreateCommand,
+    BetaMemoryTool20250818DeleteCommand,
+    BetaMemoryTool20250818InsertCommand,
+    BetaMemoryTool20250818RenameCommand,
+    BetaMemoryTool20250818StrReplaceCommand,
+)
+from ._beta_functions import BetaBuiltinFunctionTool, BetaFunctionToolResultType, BetaAsyncBuiltinFunctionTool
+
+
+class BetaAbstractMemoryTool(BetaBuiltinFunctionTool):
+    """Abstract base class for memory tool implementations.
+
+    This class provides the interface for implementing a custom memory backend for Claude.
+
+    Subclass this to create your own memory storage solution (e.g., database, cloud storage, encrypted files, etc.).
+
+    Example usage:
+
+    ```py
+    class MyMemoryTool(BetaAbstractMemoryTool):
+        def view(self, command: BetaMemoryTool20250818ViewCommand) -> BetaFunctionToolResultType:
+            ...
+            return "view result"
+
+        def create(self, command: BetaMemoryTool20250818CreateCommand) -> BetaFunctionToolResultType:
+            ...
+            return "created successfully"
+
+        # ... implement other abstract methods
+
+
+    client = Anthropic()
+    memory_tool = MyMemoryTool()
+    message = client.beta.messages.run_tools(
+        model="claude-sonnet-4-5",
+        messages=[{"role": "user", "content": "Remember that I like coffee"}],
+        tools=[memory_tool],
+    ).until_done()
+    ```
+    """
+
+    def __init__(self, *, cache_control: BetaCacheControlEphemeralParam | None = None) -> None:
+        super().__init__()
+        self._cache_control = cache_control
+
+    @override
+    def to_dict(self) -> BetaMemoryTool20250818Param:
+        param: BetaMemoryTool20250818Param = {"type": "memory_20250818", "name": "memory"}
+
+        if self._cache_control is not None:
+            param["cache_control"] = self._cache_control
+
+        return param
+
+    @override
+    def call(self, input: object) -> BetaFunctionToolResultType:
+        command = cast(
+            BetaMemoryTool20250818Command,
+            construct_type_unchecked(value=input, type_=cast(Any, BetaMemoryTool20250818Command)),
+        )
+        return self.execute(command)
+
+    def execute(self, command: BetaMemoryTool20250818Command) -> BetaFunctionToolResultType:
+        """Execute a memory command and return the result.
+
+        This method dispatches to the appropriate handler method based on the
+        command type (view, create, str_replace, insert, delete, rename).
+
+        You typically don't need to override this method.
+        """
+        if command.command == "view":
+            return self.view(command)
+        elif command.command == "create":
+            return self.create(command)
+        elif command.command == "str_replace":
+            return self.str_replace(command)
+        elif command.command == "insert":
+            return self.insert(command)
+        elif command.command == "delete":
+            return self.delete(command)
+        elif command.command == "rename":
+            return self.rename(command)
+        elif TYPE_CHECKING:  # type: ignore[unreachable]
+            assert_never(command)
+        else:
+            raise NotImplementedError(f"Unknown command: {command.command}")
+
+    @abstractmethod
+    def view(self, command: BetaMemoryTool20250818ViewCommand) -> BetaFunctionToolResultType:
+        """View the contents of a memory path."""
+        pass
+
+    @abstractmethod
+    def create(self, command: BetaMemoryTool20250818CreateCommand) -> BetaFunctionToolResultType:
+        """Create a new memory file with the specified content."""
+        pass
+
+    @abstractmethod
+    def str_replace(self, command: BetaMemoryTool20250818StrReplaceCommand) -> BetaFunctionToolResultType:
+        """Replace text in a memory file."""
+        pass
+
+    @abstractmethod
+    def insert(self, command: BetaMemoryTool20250818InsertCommand) -> BetaFunctionToolResultType:
+        """Insert text at a specific line number in a memory file."""
+        pass
+
+    @abstractmethod
+    def delete(self, command: BetaMemoryTool20250818DeleteCommand) -> BetaFunctionToolResultType:
+        """Delete a memory file or directory."""
+        pass
+
+    @abstractmethod
+    def rename(self, command: BetaMemoryTool20250818RenameCommand) -> BetaFunctionToolResultType:
+        """Rename or move a memory file or directory."""
+        pass
+
+    def clear_all_memory(self) -> BetaFunctionToolResultType:
+        """Clear all memory data."""
+        raise NotImplementedError("clear_all_memory not implemented")
+
+
+class BetaAsyncAbstractMemoryTool(BetaAsyncBuiltinFunctionTool):
+    """Abstract base class for memory tool implementations.
+
+    This class provides the interface for implementing a custom memory backend for Claude.
+
+    Subclass this to create your own memory storage solution (e.g., database, cloud storage, encrypted files, etc.).
+
+    Example usage:
+
+    ```py
+    class MyMemoryTool(BetaAbstractMemoryTool):
+        def view(self, command: BetaMemoryTool20250818ViewCommand) -> BetaFunctionToolResultType:
+            ...
+            return "view result"
+
+        def create(self, command: BetaMemoryTool20250818CreateCommand) -> BetaFunctionToolResultType:
+            ...
+            return "created successfully"
+
+        # ... implement other abstract methods
+
+
+    client = Anthropic()
+    memory_tool = MyMemoryTool()
+    message = client.beta.messages.run_tools(
+        model="claude-3-5-sonnet-20241022",
+        messages=[{"role": "user", "content": "Remember that I like coffee"}],
+        tools=[memory_tool],
+    ).until_done()
+    ```
+    """
+
+    def __init__(self, *, cache_control: BetaCacheControlEphemeralParam | None = None) -> None:
+        super().__init__()
+        self._cache_control = cache_control
+
+    @override
+    def to_dict(self) -> BetaMemoryTool20250818Param:
+        param: BetaMemoryTool20250818Param = {"type": "memory_20250818", "name": "memory"}
+
+        if self._cache_control is not None:
+            param["cache_control"] = self._cache_control
+
+        return param
+
+    @override
+    async def call(self, input: object) -> BetaFunctionToolResultType:
+        command = cast(
+            BetaMemoryTool20250818Command,
+            construct_type_unchecked(value=input, type_=cast(Any, BetaMemoryTool20250818Command)),
+        )
+        return await self.execute(command)
+
+    async def execute(self, command: BetaMemoryTool20250818Command) -> BetaFunctionToolResultType:
+        """Execute a memory command and return the result.
+
+        This method dispatches to the appropriate handler method based on the
+        command type (view, create, str_replace, insert, delete, rename).
+
+        You typically don't need to override this method.
+        """
+        if command.command == "view":
+            return await self.view(command)
+        elif command.command == "create":
+            return await self.create(command)
+        elif command.command == "str_replace":
+            return await self.str_replace(command)
+        elif command.command == "insert":
+            return await self.insert(command)
+        elif command.command == "delete":
+            return await self.delete(command)
+        elif command.command == "rename":
+            return await self.rename(command)
+        elif TYPE_CHECKING:  # type: ignore[unreachable]
+            assert_never(command)
+        else:
+            raise NotImplementedError(f"Unknown command: {command.command}")
+
+    @abstractmethod
+    async def view(self, command: BetaMemoryTool20250818ViewCommand) -> BetaFunctionToolResultType:
+        """View the contents of a memory path."""
+        pass
+
+    @abstractmethod
+    async def create(self, command: BetaMemoryTool20250818CreateCommand) -> BetaFunctionToolResultType:
+        """Create a new memory file with the specified content."""
+        pass
+
+    @abstractmethod
+    async def str_replace(self, command: BetaMemoryTool20250818StrReplaceCommand) -> BetaFunctionToolResultType:
+        """Replace text in a memory file."""
+        pass
+
+    @abstractmethod
+    async def insert(self, command: BetaMemoryTool20250818InsertCommand) -> BetaFunctionToolResultType:
+        """Insert text at a specific line number in a memory file."""
+        pass
+
+    @abstractmethod
+    async def delete(self, command: BetaMemoryTool20250818DeleteCommand) -> BetaFunctionToolResultType:
+        """Delete a memory file or directory."""
+        pass
+
+    @abstractmethod
+    async def rename(self, command: BetaMemoryTool20250818RenameCommand) -> BetaFunctionToolResultType:
+        """Rename or move a memory file or directory."""
+        pass
+
+    async def clear_all_memory(self) -> BetaFunctionToolResultType:
+        """Clear all memory data."""
+        raise NotImplementedError("clear_all_memory not implemented")

anthropic/lib/tools/_beta_functions.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+from abc import ABC, abstractmethod
 from typing import Any, Union, Generic, TypeVar, Callable, Iterable, Coroutine, cast, overload
 from inspect import iscoroutinefunction
 from typing_extensions import TypeAlias, override
@@ -13,6 +14,7 @@ from ... import _compat
 from ..._utils import is_dict
 from ..._compat import cached_property
 from ..._models import TypeAdapter
+from ...types.beta import BetaToolUnionParam
 from ..._utils._utils import CallableT
 from ...types.tool_param import ToolParam, InputSchema
 from ...types.beta.beta_tool_result_block_param import Content as BetaContent
@@ -28,6 +30,30 @@ AsyncFunction = Callable[..., Coroutine[Any, Any, BetaFunctionToolResultType]]
 AsyncFunctionT = TypeVar("AsyncFunctionT", bound=AsyncFunction)
 
 
+class BetaBuiltinFunctionTool(ABC):
+    @abstractmethod
+    def to_dict(self) -> BetaToolUnionParam: ...
+
+    @abstractmethod
+    def call(self, input: object) -> BetaFunctionToolResultType: ...
+
+    @property
+    def name(self) -> str:
+        return self.to_dict()["name"]
+
+
+class BetaAsyncBuiltinFunctionTool(ABC):
+    @abstractmethod
+    def to_dict(self) -> BetaToolUnionParam: ...
+
+    @abstractmethod
+    async def call(self, input: object) -> BetaFunctionToolResultType: ...
+
+    @property
+    def name(self) -> str:
+        return self.to_dict()["name"]
+
+
 class BaseFunctionTool(Generic[CallableT]):
     func: CallableT
     """The function this tool is wrapping"""
@@ -287,3 +313,7 @@ def beta_async_tool(
         )
 
     return decorator
+
+
+BetaRunnableTool = Union[BetaFunctionTool[Any], BetaBuiltinFunctionTool]
+BetaAsyncRunnableTool = Union[BetaAsyncFunctionTool[Any], BetaAsyncBuiltinFunctionTool]

anthropic/lib/tools/_beta_runner.py

@@ -22,7 +22,14 @@ import httpx
 from ..._types import Body, Query, Headers, NotGiven
 from ..._utils import consume_sync_iterator, consume_async_iterator
 from ...types.beta import BetaMessage, BetaContentBlock, BetaMessageParam
-from ._beta_functions import BetaFunctionTool, BetaAsyncFunctionTool
+from ._beta_functions import (
+    BetaFunctionTool,
+    BetaRunnableTool,
+    BetaAsyncFunctionTool,
+    BetaAsyncRunnableTool,
+    BetaBuiltinFunctionTool,
+    BetaAsyncBuiltinFunctionTool,
+)
 from ..streaming._beta_messages import BetaMessageStream, BetaAsyncMessageStream
 from ...types.beta.message_create_params import MessageCreateParamsBase
 from ...types.beta.beta_tool_result_block_param import BetaToolResultBlockParam
@@ -31,7 +38,12 @@ if TYPE_CHECKING:
     from ..._client import Anthropic, AsyncAnthropic
 
 
-AnyFunctionToolT = TypeVar("AnyFunctionToolT", bound=Union[BetaFunctionTool[Any], BetaAsyncFunctionTool[Any]])
+AnyFunctionToolT = TypeVar(
+    "AnyFunctionToolT",
+    bound=Union[
+        BetaFunctionTool[Any], BetaAsyncFunctionTool[Any], BetaBuiltinFunctionTool, BetaAsyncBuiltinFunctionTool
+    ],
+)
 RunnerItemT = TypeVar("RunnerItemT")
 
 log = logging.getLogger(__name__)
@@ -97,13 +109,13 @@ class BaseToolRunner(Generic[AnyFunctionToolT]):
         return False
 
 
-class BaseSyncToolRunner(BaseToolRunner[BetaFunctionTool[Any]], Generic[RunnerItemT], ABC):
+class BaseSyncToolRunner(BaseToolRunner[BetaRunnableTool], Generic[RunnerItemT], ABC):
     def __init__(
         self,
         *,
         params: MessageCreateParamsBase,
         options: RequestOptions,
-        tools: Iterable[BetaFunctionTool[Any]],
+        tools: Iterable[BetaRunnableTool],
         client: Anthropic,
         max_iterations: int | None = None,
     ) -> None:
@@ -250,13 +262,13 @@ class BetaStreamingToolRunner(BaseSyncToolRunner[BetaMessageStream]):
                 message = stream.get_final_message()
 
 
-class BaseAsyncToolRunner(BaseToolRunner[BetaAsyncFunctionTool[Any]], Generic[RunnerItemT], ABC):
+class BaseAsyncToolRunner(BaseToolRunner[BetaAsyncRunnableTool], Generic[RunnerItemT], ABC):
     def __init__(
         self,
         *,
         params: MessageCreateParamsBase,
         options: RequestOptions,
-        tools: Iterable[BetaAsyncFunctionTool[Any]],
+        tools: Iterable[BetaAsyncRunnableTool],
         client: AsyncAnthropic,
         max_iterations: int | None = None,
     ) -> None: