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

anthropic/lib/tools/_beta_functions.py

@@ -14,9 +14,9 @@ from ... import _compat
 from ..._utils import is_dict
 from ..._compat import cached_property
 from ..._models import TypeAdapter
-from ...types.beta import BetaToolUnionParam
+from ...types.beta import BetaToolParam, BetaToolUnionParam
 from ..._utils._utils import CallableT
-from ...types.tool_param import ToolParam, InputSchema
+from ...types.tool_param import InputSchema
 from ...types.beta.beta_tool_result_block_param import Content as BetaContent
 
 log = logging.getLogger(__name__)
@@ -39,7 +39,10 @@ class BetaBuiltinFunctionTool(ABC):
 
     @property
     def name(self) -> str:
-        return self.to_dict()["name"]
+        raw = self.to_dict()
+        if "mcp_server_name" in raw:
+            return raw["mcp_server_name"]
+        return raw["name"]
 
 
 class BetaAsyncBuiltinFunctionTool(ABC):
@@ -51,7 +54,10 @@ class BetaAsyncBuiltinFunctionTool(ABC):
 
     @property
     def name(self) -> str:
-        return self.to_dict()["name"]
+        raw = self.to_dict()
+        if "mcp_server_name" in raw:
+            return raw["mcp_server_name"]
+        return raw["name"]
 
 
 class BaseFunctionTool(Generic[CallableT]):
@@ -72,6 +78,7 @@ class BaseFunctionTool(Generic[CallableT]):
         name: str | None = None,
         description: str | None = None,
         input_schema: InputSchema | type[BaseModel] | None = None,
+        defer_loading: bool | None = None,
     ) -> None:
         if _compat.PYDANTIC_V1:
             raise RuntimeError("Tool functions are only supported with Pydantic v2")
@@ -79,6 +86,7 @@ class BaseFunctionTool(Generic[CallableT]):
         self.func = func
         self._func_with_validate = pydantic.validate_call(func)
         self.name = name or func.__name__
+        self._defer_loading = defer_loading
 
         self.description = description or self._get_description_from_docstring()
 
@@ -94,12 +102,15 @@ class BaseFunctionTool(Generic[CallableT]):
     def __call__(self) -> CallableT:
         return self.func
 
-    def to_dict(self) -> ToolParam:
-        return {
+    def to_dict(self) -> BetaToolParam:
+        defn: BetaToolParam = {
             "name": self.name,
             "description": self.description,
             "input_schema": self.input_schema,
         }
+        if self._defer_loading is not None:
+            defn["defer_loading"] = self._defer_loading
+        return defn
 
     @cached_property
     def _parsed_docstring(self) -> docstring_parser.Docstring:
@@ -211,6 +222,7 @@ def beta_tool(
     name: str | None = None,
     description: str | None = None,
     input_schema: InputSchema | type[BaseModel] | None = None,
+    defer_loading: bool | None = None,
 ) -> Callable[[FunctionT], BetaFunctionTool[FunctionT]]: ...
 
 
@@ -220,6 +232,7 @@ def beta_tool(
     name: str | None = None,
     description: str | None = None,
     input_schema: InputSchema | type[BaseModel] | None = None,
+    defer_loading: bool | None = None,
 ) -> BetaFunctionTool[FunctionT] | Callable[[FunctionT], BetaFunctionTool[FunctionT]]:
     """Create a FunctionTool from a function with automatic schema inference.
 
@@ -239,11 +252,15 @@ def beta_tool(
 
     if func is not None:
         # @beta_tool called without parentheses
-        return BetaFunctionTool(func=func, name=name, description=description, input_schema=input_schema)
+        return BetaFunctionTool(
+            func=func, name=name, description=description, input_schema=input_schema, defer_loading=defer_loading
+        )
 
     # @beta_tool()
     def decorator(func: FunctionT) -> BetaFunctionTool[FunctionT]:
-        return BetaFunctionTool(func=func, name=name, description=description, input_schema=input_schema)
+        return BetaFunctionTool(
+            func=func, name=name, description=description, input_schema=input_schema, defer_loading=defer_loading
+        )
 
     return decorator
 
@@ -259,6 +276,7 @@ def beta_async_tool(
     name: str | None = None,
     description: str | None = None,
     input_schema: InputSchema | type[BaseModel] | None = None,
+    defer_loading: bool | None = None,
 ) -> BetaAsyncFunctionTool[AsyncFunctionT]: ...
 
 
@@ -268,6 +286,7 @@ def beta_async_tool(
     name: str | None = None,
     description: str | None = None,
     input_schema: InputSchema | type[BaseModel] | None = None,
+    defer_loading: bool | None = None,
 ) -> Callable[[AsyncFunctionT], BetaAsyncFunctionTool[AsyncFunctionT]]: ...
 
 
@@ -277,6 +296,7 @@ def beta_async_tool(
     name: str | None = None,
     description: str | None = None,
     input_schema: InputSchema | type[BaseModel] | None = None,
+    defer_loading: bool | None = None,
 ) -> BetaAsyncFunctionTool[AsyncFunctionT] | Callable[[AsyncFunctionT], BetaAsyncFunctionTool[AsyncFunctionT]]:
     """Create an AsyncFunctionTool from a function with automatic schema inference.
 
@@ -301,6 +321,7 @@ def beta_async_tool(
             name=name,
             description=description,
             input_schema=input_schema,
+            defer_loading=defer_loading,
         )
 
     # @beta_async_tool()
@@ -310,6 +331,7 @@ def beta_async_tool(
             name=name,
             description=description,
             input_schema=input_schema,
+            defer_loading=defer_loading,
         )
 
     return decorator

anthropic/lib/tools/_beta_runner.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+import warnings
 from abc import ABC, abstractmethod
 from typing import (
     TYPE_CHECKING,
@@ -31,6 +32,7 @@ from ._beta_functions import (
     BetaBuiltinFunctionTool,
     BetaAsyncBuiltinFunctionTool,
 )
+from ._beta_compaction_control import DEFAULT_THRESHOLD, DEFAULT_SUMMARY_PROMPT, CompactionControl
 from ..streaming._beta_messages import BetaMessageStream, BetaAsyncMessageStream
 from ...types.beta.parsed_beta_message import ResponseFormatT, ParsedBetaMessage, ParsedBetaContentBlock
 from ...types.beta.message_create_params import ParseMessageCreateParamsBase
@@ -66,6 +68,7 @@ class BaseToolRunner(Generic[AnyFunctionToolT, ResponseFormatT]):
         options: RequestOptions,
         tools: Iterable[AnyFunctionToolT],
         max_iterations: int | None = None,
+        compaction_control: CompactionControl | None = None,
     ) -> None:
         self._tools_by_name = {tool.name: tool for tool in tools}
         self._params: ParseMessageCreateParamsBase[ResponseFormatT] = {
@@ -77,6 +80,7 @@ class BaseToolRunner(Generic[AnyFunctionToolT, ResponseFormatT]):
         self._cached_tool_call_response: BetaMessageParam | None = None
         self._max_iterations = max_iterations
         self._iteration_count = 0
+        self._compaction_control = compaction_control
 
     def set_messages_params(
         self,
@@ -122,9 +126,17 @@ class BaseSyncToolRunner(BaseToolRunner[BetaRunnableTool, ResponseFormatT], Gene
         tools: Iterable[BetaRunnableTool],
         client: Anthropic,
         max_iterations: int | None = None,
+        compaction_control: CompactionControl | None = None,
     ) -> None:
-        super().__init__(params=params, options=options, tools=tools, max_iterations=max_iterations)
+        super().__init__(
+            params=params,
+            options=options,
+            tools=tools,
+            max_iterations=max_iterations,
+            compaction_control=compaction_control,
+        )
         self._client = client
+
         self._iterator = self.__run__()
         self._last_message: (
             Callable[[], ParsedBetaMessage[ResponseFormatT]] | ParsedBetaMessage[ResponseFormatT] | None
@@ -143,31 +155,112 @@ class BaseSyncToolRunner(BaseToolRunner[BetaRunnableTool, ResponseFormatT], Gene
         raise NotImplementedError()
         yield  # type: ignore[unreachable]
 
-    def __run__(self) -> Iterator[RunnerItemT]:
-        with self._handle_request() as item:
-            yield item
-            message = self._get_last_message()
-            assert message is not None
-        self._iteration_count += 1
+    def _check_and_compact(self) -> bool:
+        """
+        Check token usage and compact messages if threshold exceeded.
+        Returns True if compaction was performed, False otherwise.
+        """
+        if self._compaction_control is None or not self._compaction_control["enabled"]:
+            return False
+
+        message = self._get_last_message()
+        tokens_used = 0
+        if message is not None:
+            total_input_tokens = (
+                message.usage.input_tokens
+                + (message.usage.cache_creation_input_tokens or 0)
+                + (message.usage.cache_read_input_tokens or 0)
+            )
+            tokens_used = total_input_tokens + message.usage.output_tokens
+
+        threshold = self._compaction_control.get("context_token_threshold", DEFAULT_THRESHOLD)
+
+        if tokens_used < threshold:
+            return False
+
+        # Perform compaction
+        log.info(f"Token usage {tokens_used} has exceeded the threshold of {threshold}. Performing compaction.")
+
+        model = self._compaction_control.get("model", self._params["model"])
+
+        messages = list(self._params["messages"])
+
+        if messages[-1]["role"] == "assistant":
+            # Remove tool_use blocks from the last message to avoid 400 error
+            # (tool_use requires tool_result, which we don't have yet)
+            non_tool_blocks = [
+                block
+                for block in messages[-1]["content"]
+                if isinstance(block, dict) and block.get("type") != "tool_use"
+            ]
+
+            if non_tool_blocks:
+                messages[-1]["content"] = non_tool_blocks
+            else:
+                messages.pop()
+
+        messages = [
+            *messages,
+            BetaMessageParam(
+                role="user",
+                content=self._compaction_control.get("summary_prompt", DEFAULT_SUMMARY_PROMPT),
+            ),
+        ]
 
-        while not self._should_stop():
-            response = self.generate_tool_call_response()
-            if response is None:
-                log.debug("Tool call was not requested, exiting from tool runner loop.")
-                return
+        response = self._client.beta.messages.create(
+            model=model,
+            messages=messages,
+            max_tokens=self._params["max_tokens"],
+            extra_headers={"X-Stainless-Helper": "compaction"},
+        )
 
-            if not self._messages_modified:
-                self.append_messages(message, response)
+        log.info(f"Compaction complete. New token usage: {response.usage.output_tokens}")
 
-            self._iteration_count += 1
-            self._messages_modified = False
-            self._cached_tool_call_response = None
+        first_content = list(response.content)[0]
 
+        if first_content.type != "text":
+            raise ValueError("Compaction response content is not of type 'text'")
+
+        self.set_messages_params(
+            lambda params: {
+                **params,
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": [
+                            {
+                                "type": "text",
+                                "text": first_content.text,
+                            }
+                        ],
+                    }
+                ],
+            }
+        )
+        return True
+
+    def __run__(self) -> Iterator[RunnerItemT]:
+        while not self._should_stop():
             with self._handle_request() as item:
                 yield item
                 message = self._get_last_message()
                 assert message is not None
 
+            self._iteration_count += 1
+
+            # If the compaction was performed, skip tool call generation this iteration
+            if not self._check_and_compact():
+                response = self.generate_tool_call_response()
+                if response is None:
+                    log.debug("Tool call was not requested, exiting from tool runner loop.")
+                    return
+
+                if not self._messages_modified:
+                    self.append_messages(message, response)
+
+            self._messages_modified = False
+            self._cached_tool_call_response = None
+
     def until_done(self) -> ParsedBetaMessage[ResponseFormatT]:
         """
         Consumes the tool runner stream and returns the last message if it has not been consumed yet.
@@ -206,6 +299,14 @@ class BaseSyncToolRunner(BaseToolRunner[BetaRunnableTool, ResponseFormatT], Gene
         for tool_use in tool_use_blocks:
             tool = self._tools_by_name.get(tool_use.name)
             if tool is None:
+                warnings.warn(
+                    f"Tool '{tool_use.name}' not found in tool runner. "
+                    f"Available tools: {list(self._tools_by_name.keys())}. "
+                    f"If using a raw tool definition, handle the tool call manually and use `append_messages()` to add the result. "
+                    f"Otherwise, pass the tool using `beta_tool(func)` or a `@beta_tool` decorated function.",
+                    UserWarning,
+                    stacklevel=3,
+                )
                 results.append(
                     {
                         "type": "tool_result",
@@ -274,9 +375,17 @@ class BaseAsyncToolRunner(
         tools: Iterable[BetaAsyncRunnableTool],
         client: AsyncAnthropic,
         max_iterations: int | None = None,
+        compaction_control: CompactionControl | None = None,
     ) -> None:
-        super().__init__(params=params, options=options, tools=tools, max_iterations=max_iterations)
+        super().__init__(
+            params=params,
+            options=options,
+            tools=tools,
+            max_iterations=max_iterations,
+            compaction_control=compaction_control,
+        )
         self._client = client
+
         self._iterator = self.__run__()
         self._last_message: (
             Callable[[], Coroutine[None, None, ParsedBetaMessage[ResponseFormatT]]]
@@ -297,30 +406,112 @@ class BaseAsyncToolRunner(
         raise NotImplementedError()
         yield  # type: ignore[unreachable]
 
-    async def __run__(self) -> AsyncIterator[RunnerItemT]:
-        async with self._handle_request() as item:
-            yield item
-            message = await self._get_last_message()
-            assert message is not None
-        self._iteration_count += 1
+    async def _check_and_compact(self) -> bool:
+        """
+        Check token usage and compact messages if threshold exceeded.
+        Returns True if compaction was performed, False otherwise.
+        """
+        if self._compaction_control is None or not self._compaction_control["enabled"]:
+            return False
+
+        message = await self._get_last_message()
+        tokens_used = 0
+        if message is not None:
+            total_input_tokens = (
+                message.usage.input_tokens
+                + (message.usage.cache_creation_input_tokens or 0)
+                + (message.usage.cache_read_input_tokens or 0)
+            )
+            tokens_used = total_input_tokens + message.usage.output_tokens
+
+        threshold = self._compaction_control.get("context_token_threshold", DEFAULT_THRESHOLD)
+
+        if tokens_used < threshold:
+            return False
+
+        # Perform compaction
+        log.info(f"Token usage {tokens_used} has exceeded the threshold of {threshold}. Performing compaction.")
+
+        model = self._compaction_control.get("model", self._params["model"])
+
+        messages = list(self._params["messages"])
+
+        if messages[-1]["role"] == "assistant":
+            # Remove tool_use blocks from the last message to avoid 400 error
+            # (tool_use requires tool_result, which we don't have yet)
+            non_tool_blocks = [
+                block
+                for block in messages[-1]["content"]
+                if isinstance(block, dict) and block.get("type") != "tool_use"
+            ]
+
+            if non_tool_blocks:
+                messages[-1]["content"] = non_tool_blocks
+            else:
+                messages.pop()
+
+        messages = [
+            *self._params["messages"],
+            BetaMessageParam(
+                role="user",
+                content=self._compaction_control.get("summary_prompt", DEFAULT_SUMMARY_PROMPT),
+            ),
+        ]
 
-        while not self._should_stop():
-            response = await self.generate_tool_call_response()
-            if response is None:
-                log.debug("Tool call was not requested, exiting from tool runner loop.")
-                return
+        response = await self._client.beta.messages.create(
+            model=model,
+            messages=messages,
+            max_tokens=self._params["max_tokens"],
+            extra_headers={"X-Stainless-Helper": "compaction"},
+        )
 
-            if not self._messages_modified:
-                self.append_messages(message, response)
-            self._iteration_count += 1
-            self._messages_modified = False
-            self._cached_tool_call_response = None
+        log.info(f"Compaction complete. New token usage: {response.usage.output_tokens}")
+
+        first_content = list(response.content)[0]
+
+        if first_content.type != "text":
+            raise ValueError("Compaction response content is not of type 'text'")
+
+        self.set_messages_params(
+            lambda params: {
+                **params,
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": [
+                            {
+                                "type": "text",
+                                "text": first_content.text,
+                            }
+                        ],
+                    }
+                ],
+            }
+        )
+        return True
 
+    async def __run__(self) -> AsyncIterator[RunnerItemT]:
+        while not self._should_stop():
             async with self._handle_request() as item:
                 yield item
                 message = await self._get_last_message()
                 assert message is not None
 
+            self._iteration_count += 1
+
+            # If the compaction was performed, skip tool call generation this iteration
+            if not await self._check_and_compact():
+                response = await self.generate_tool_call_response()
+                if response is None:
+                    log.debug("Tool call was not requested, exiting from tool runner loop.")
+                    return
+
+                if not self._messages_modified:
+                    self.append_messages(message, response)
+
+            self._messages_modified = False
+            self._cached_tool_call_response = None
+
     async def until_done(self) -> ParsedBetaMessage[ResponseFormatT]:
         """
         Consumes the tool runner stream and returns the last message if it has not been consumed yet.
@@ -372,6 +563,14 @@ class BaseAsyncToolRunner(
         for tool_use in tool_use_blocks:
             tool = self._tools_by_name.get(tool_use.name)
             if tool is None:
+                warnings.warn(
+                    f"Tool '{tool_use.name}' not found in tool runner. "
+                    f"Available tools: {list(self._tools_by_name.keys())}. "
+                    f"If using a raw tool definition, handle the tool call manually and use `append_messages()` to add the result. "
+                    f"Otherwise, pass the tool using `beta_async_tool(func)` or a `@beta_async_tool` decorated function.",
+                    UserWarning,
+                    stacklevel=3,
+                )
                 results.append(
                     {
                         "type": "tool_result",