anthropic 0.74.1__tar.gz → 0.75.0__tar.gz

anthropic-0.75.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.75.0"
+}

{anthropic-0.74.1 → anthropic-0.75.0}/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.75.0 (2025-11-24)
+
+Full Changelog: [v0.74.1...v0.75.0](https://github.com/anthropics/anthropic-sdk-python/compare/v0.74.1...v0.75.0)
+
+### Features
+
+* **api:** adds support for Claude Opus 4.5, Effort, Advance Tool Use Features, Autocompaction, and Computer Use v5 ([5c3e633](https://github.com/anthropics/anthropic-sdk-python/commit/5c3e633395acc100c45e8a403f1b5be4d17a3b32))
+
+
+### Bug Fixes
+
+* **internal:** small fixes ([36c82f7](https://github.com/anthropics/anthropic-sdk-python/commit/36c82f72b588bd549770a89072dd52d6f9e5b6a5))
+
+
+### Chores
+
+* fix lint issues ([4f1fd54](https://github.com/anthropics/anthropic-sdk-python/commit/4f1fd54143b79a4a7976dfb332ec7bfc666d1598))
+
 ## 0.74.1 (2025-11-19)
 
 Full Changelog: [v0.74.0...v0.74.1](https://github.com/anthropics/anthropic-sdk-python/compare/v0.74.0...v0.74.1)

{anthropic-0.74.1 → anthropic-0.75.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: anthropic
-Version: 0.74.1
+Version: 0.75.0
 Summary: The official Python library for the anthropic API
 Project-URL: Homepage, https://github.com/anthropics/anthropic-sdk-python
 Project-URL: Repository, https://github.com/anthropics/anthropic-sdk-python

{anthropic-0.74.1 → anthropic-0.75.0}/api.md

@@ -256,6 +256,7 @@ from anthropic.types.beta import (
     BetaContextManagementConfig,
     BetaContextManagementResponse,
     BetaCountTokensContextManagementResponse,
+    BetaDirectCaller,
     BetaDocumentBlock,
     BetaFileDocumentSource,
     BetaFileImageSource,
@@ -264,9 +265,12 @@ from anthropic.types.beta import (
     BetaInputTokensClearAtLeast,
     BetaInputTokensTrigger,
     BetaJSONOutputFormat,
+    BetaMCPToolConfig,
+    BetaMCPToolDefaultConfig,
     BetaMCPToolResultBlock,
     BetaMCPToolUseBlock,
     BetaMCPToolUseBlockParam,
+    BetaMCPToolset,
     BetaMemoryTool20250818,
     BetaMemoryTool20250818Command,
     BetaMemoryTool20250818CreateCommand,
@@ -280,6 +284,7 @@ from anthropic.types.beta import (
     BetaMessageParam,
     BetaMessageTokensCount,
     BetaMetadata,
+    BetaOutputConfig,
     BetaPlainTextSource,
     BetaRawContentBlockDelta,
     BetaRawContentBlockDeltaEvent,
@@ -296,6 +301,7 @@ from anthropic.types.beta import (
     BetaRequestMCPServerURLDefinition,
     BetaRequestMCPToolResultBlockParam,
     BetaSearchResultBlockParam,
+    BetaServerToolCaller,
     BetaServerToolUsage,
     BetaServerToolUseBlock,
     BetaServerToolUseBlockParam,
@@ -335,7 +341,18 @@ from anthropic.types.beta import (
     BetaToolChoiceTool,
     BetaToolComputerUse20241022,
     BetaToolComputerUse20250124,
+    BetaToolComputerUse20251124,
+    BetaToolReferenceBlock,
+    BetaToolReferenceBlockParam,
     BetaToolResultBlockParam,
+    BetaToolSearchToolBm25_20251119,
+    BetaToolSearchToolRegex20251119,
+    BetaToolSearchToolResultBlock,
+    BetaToolSearchToolResultBlockParam,
+    BetaToolSearchToolResultError,
+    BetaToolSearchToolResultErrorParam,
+    BetaToolSearchToolSearchResultBlock,
+    BetaToolSearchToolSearchResultBlockParam,
     BetaToolTextEditor20241022,
     BetaToolTextEditor20250124,
     BetaToolTextEditor20250429,

anthropic-0.75.0/examples/auto_compaction.py

@@ -0,0 +1,77 @@
+"""Show the full summary content after compaction"""
+
+import json
+
+from anthropic import Anthropic
+from anthropic.lib.tools import beta_tool
+
+
+@beta_tool
+def search(query: str) -> str:
+    """Search for information."""
+    return json.dumps(
+        {
+            "results": [
+                {"title": f"Result for {query}", "content": "Lorem ipsum " * 100},
+                {"title": f"More on {query}", "content": "Detailed info " * 100},
+            ]
+        }
+    )
+
+
+@beta_tool
+def done(summary: str) -> str:  # noqa: ARG001
+    """Call when finished."""
+    return "Complete"
+
+
+client = Anthropic()
+
+runner = client.beta.messages.tool_runner(
+    model="claude-sonnet-4-20250514",
+    max_tokens=4096,
+    tools=[search, done],
+    messages=[
+        {
+            "role": "user",
+            "content": "You MUST search for EACH of these animals ONE BY ONE: dogs, cats, birds, fish, horses, elephants, lions, tigers, bears, wolves. After searching for ALL of them, call done.",
+        }
+    ],
+    compaction_control={
+        "enabled": True,
+        "context_token_threshold": 3000,  # Even lower threshold
+    },
+)
+
+prev_msg_count = 0
+for i, message in enumerate(runner):
+    curr_msg_count = len(list(runner._params["messages"]))
+    print(f"Turn {i + 1}: {message.usage.input_tokens} input tokens, {curr_msg_count} messages")
+
+    if curr_msg_count < prev_msg_count:
+        print("=" * 70)
+        print("🔄 COMPACTION OCCURRED!")
+        print("=" * 70)
+        print(f"Messages went from {prev_msg_count} → {curr_msg_count}")
+        print(f"Input tokens: {message.usage.input_tokens}")
+        print("\nNEW MESSAGES LIST:")
+        print("-" * 70)
+
+        for msg in runner._params["messages"]:
+            role = msg.get("role", "?")
+            content = msg.get("content", "")
+
+            if isinstance(content, list):
+                for block in content:
+                    if isinstance(block, dict) and block.get("type") == "text":
+                        print(f"\n[{role}] TEXT BLOCK:")
+                        print(block.get("text", ""))
+            elif isinstance(content, str):
+                print(f"\n[{role}]:")
+                print(content)
+
+        print("-" * 70)
+
+    prev_msg_count = curr_msg_count
+
+print("\n✅ Done!")

anthropic-0.75.0/examples/tools_runner_search_tool.py

@@ -0,0 +1,80 @@
+import json
+from typing import Any, List
+from typing_extensions import Literal
+
+import rich
+
+from anthropic import Anthropic, beta_tool
+from anthropic.lib.tools import BetaFunctionTool, BetaFunctionToolResultType
+from anthropic.types.beta import BetaToolReferenceBlockParam
+
+client = Anthropic()
+
+
+@beta_tool(defer_loading=True)
+def get_weather(location: str, units: Literal["c", "f"]) -> str:
+    """Lookup the weather for a given city in either celsius or fahrenheit
+
+    Args:
+        location: The city and state, e.g. San Francisco, CA
+        units: Unit for the output, either 'c' for celsius or 'f' for fahrenheit
+    Returns:
+        A dictionary containing the location, temperature, and weather condition.
+    """
+    # Simulate a weather API call
+    print(f"Fetching weather for {location} in {units}")
+
+    # Here you would typically make an API call to a weather service
+    # For demonstration, we return a mock response
+    if units == "c":
+        return json.dumps(
+            {
+                "location": location,
+                "temperature": "20°C",
+                "condition": "Sunny",
+            }
+        )
+    else:
+        return json.dumps(
+            {
+                "location": location,
+                "temperature": "68°F",
+                "condition": "Sunny",
+            }
+        )
+
+
+def make_tool_searcher(tools: List[BetaFunctionTool[Any]]) -> BetaFunctionTool[Any]:
+    """Returns a tool that Claude can use to search through all available tools"""
+
+    @beta_tool
+    def search_available_tools(*, keyword: str) -> BetaFunctionToolResultType:
+        """Search for useful tools using a query string"""
+
+        results: list[BetaToolReferenceBlockParam] = []
+        for tool in tools:
+            if keyword in json.dumps(tool.to_dict()):
+                results.append({"type": "tool_reference", "tool_name": tool.name})
+
+        return results
+
+    return search_available_tools
+
+
+def main() -> None:
+    tools: list[BetaFunctionTool[Any]] = [
+        get_weather,
+        # ... many more tools
+    ]
+    runner = client.beta.messages.tool_runner(
+        max_tokens=1024,
+        model="claude-sonnet-4-5-20250929",
+        tools=[*tools, make_tool_searcher(tools)],
+        messages=[{"role": "user", "content": "What is the weather in SF?"}],
+        betas=["tool-search-tool-2025-10-19"],
+    )
+    for message in runner:
+        rich.print(message)
+
+
+main()

{anthropic-0.74.1 → anthropic-0.75.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "anthropic"
-version = "0.74.1"
+version = "0.75.0"
 description = "The official Python library for the anthropic API"
 dynamic = ["readme"]
 license = "MIT"
@@ -160,7 +160,7 @@ show_error_codes = true
 #
 # We also exclude our `tests` as mypy doesn't always infer
 # types correctly and Pyright will still catch any type errors.
-exclude = ['src/anthropic/_files.py', '_dev/.*.py', 'tests/.*', 'examples/mcp_server_weather.py', 'examples/tools_with_mcp.py', 'examples/memory/basic.py', 'src/anthropic/lib/_parse/_transform.py']
+exclude = ['src/anthropic/_files.py', '_dev/.*.py', 'tests/.*', 'examples/mcp_server_weather.py', 'examples/tools_with_mcp.py', 'examples/memory/basic.py', 'src/anthropic/lib/_parse/_transform.py', 'src/anthropic/lib/tools/_beta_functions.py']
 
 strict_equality = true
 implicit_reexport = true

{anthropic-0.74.1 → anthropic-0.75.0}/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.74.1"  # x-release-please-version
+__version__ = "0.75.0"  # x-release-please-version

{anthropic-0.74.1 → anthropic-0.75.0}/src/anthropic/lib/streaming/_beta_messages.py

@@ -468,7 +468,7 @@ def accumulate_event(
         current_snapshot.content.append(
             cast(
                 Any,  # Pydantic does not support generic unions at runtime
-                construct_type(type_=ParsedBetaContentBlock, value=event.content_block.model_dump()),
+                construct_type(type_=ParsedBetaContentBlock, value=event.content_block.to_dict()),
             ),
         )
     elif event.type == "content_block_delta":

anthropic-0.75.0/src/anthropic/lib/tools/_beta_compaction_control.py

@@ -0,0 +1,48 @@
+from typing import TypedDict
+from typing_extensions import Required
+
+DEFAULT_SUMMARY_PROMPT = """You have been working on the task described above but have not yet completed it. Write a continuation summary that will allow you (or another instance of yourself) to resume work efficiently in a future context window where the conversation history will be replaced with this summary. Your summary should be structured, concise, and actionable. Include:
+1. Task Overview
+The user's core request and success criteria
+Any clarifications or constraints they specified
+2. Current State
+What has been completed so far
+Files created, modified, or analyzed (with paths if relevant)
+Key outputs or artifacts produced
+3. Important Discoveries
+Technical constraints or requirements uncovered
+Decisions made and their rationale
+Errors encountered and how they were resolved
+What approaches were tried that didn't work (and why)
+4. Next Steps
+Specific actions needed to complete the task
+Any blockers or open questions to resolve
+Priority order if multiple steps remain
+5. Context to Preserve
+User preferences or style requirements
+Domain-specific details that aren't obvious
+Any promises made to the user
+Be concise but complete—err on the side of including information that would prevent duplicate work or repeated mistakes. Write in a way that enables immediate resumption of the task.
+Wrap your summary in <summary></summary> tags."""
+
+DEFAULT_THRESHOLD = 100_000
+
+
+class CompactionControl(TypedDict, total=False):
+    context_token_threshold: int
+    """The context token threshold at which to trigger compaction.
+    
+    When the cumulative token count (input + output) across all messages exceeds this threshold,
+    the message history will be automatically summarized and compressed. Defaults to 150,000 tokens.
+    """
+
+    model: str
+    """
+    The model to use for generating the compaction summary.
+    If not specified, defaults to the same model used for the tool runner.
+    """
+
+    summary_prompt: str
+    """The prompt used to instruct the model on how to generate the summary."""
+
+    enabled: Required[bool]

{anthropic-0.74.1 → anthropic-0.75.0}/src/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