meshagent-anthropic 0.25.0__py3-none-any.whl → 0.25.2__py3-none-any.whl

meshagent/anthropic/__init__.py

@@ -11,6 +11,8 @@ from .mcp import (
     MCPToolkitBuilder,
 )
 from .openai_responses_stream_adapter import AnthropicOpenAIResponsesStreamAdapter
+from .web_fetch import WebFetchConfig, WebFetchTool, WebFetchToolkitBuilder
+from .web_search import WebSearchConfig, WebSearchTool, WebSearchToolkitBuilder
 
 __all__ = [
     AnthropicMessagesAdapter,
@@ -22,4 +24,10 @@ __all__ = [
     MCPToolConfig,
     MCPToolset,
     MCPToolkitBuilder,
+    WebFetchConfig,
+    WebFetchTool,
+    WebFetchToolkitBuilder,
+    WebSearchConfig,
+    WebSearchTool,
+    WebSearchToolkitBuilder,
 ]

meshagent/anthropic/mcp.py

@@ -4,7 +4,9 @@ from typing import Literal, Optional
 
 from pydantic import BaseModel
 
-from meshagent.tools import BaseTool, Toolkit, ToolkitBuilder, ToolkitConfig
+from meshagent.tools import Toolkit, ToolkitBuilder, ToolkitConfig
+
+from .request_tool import AnthropicRequestTool
 
 
 # This module wraps Anthropic's official MCP connector support:
@@ -56,21 +58,17 @@ class MCPConfig(ToolkitConfig):
     betas: list[str] = [MCP_CONNECTOR_BETA]
 
 
-class MCPTool(BaseTool):
+class MCPTool(AnthropicRequestTool):
     """Non-executable tool that augments the Anthropic request."""
 
     def __init__(self, *, config: MCPConfig):
         super().__init__(name="mcp")
         self.config = config
 
-    def apply(self, *, request: dict) -> None:
+    def apply(self, *, request: dict, headers: dict) -> None:
         """Mutate an Anthropic Messages request in-place."""
 
-        # Ensure we use the beta Messages API surface.
-        betas = request.setdefault("betas", [])
-        for b in self.config.betas:
-            if b not in betas:
-                betas.append(b)
+        self.apply_betas(headers=headers, betas=self.config.betas)
 
         toolsets = self.config.toolsets
         if toolsets is None:

meshagent/anthropic/messages_adapter.py

@@ -46,7 +46,11 @@ def safe_tool_name(name: str) -> str:
 def _as_jsonable(obj: Any) -> Any:
     if isinstance(obj, dict):
         return obj
-    return obj.model_dump(mode="json")
+    return obj.model_dump(
+        mode="json",
+        exclude_none=True,
+        exclude_unset=True,
+    )
 
 
 def _text_block(text: str) -> dict:
@@ -327,6 +331,9 @@ class AnthropicMessagesAdapter(LLMAdapter[dict]):
         # The MCP connector requires `client.beta.messages.*`.
         if request.get("betas") is not None:
             return client.beta.messages
+        extra_headers = request.get("extra_headers")
+        if isinstance(extra_headers, dict) and extra_headers.get("anthropic-beta"):
+            return client.beta.messages
         return client.messages
 
     async def _create_with_optional_headers(self, *, client: Any, request: dict) -> Any:
@@ -372,11 +379,11 @@ class AnthropicMessagesAdapter(LLMAdapter[dict]):
 
     def _split_toolkits(
         self, *, toolkits: list[Toolkit]
-    ) -> tuple[list[Toolkit], list[MCPConnectorTool]]:
+    ) -> tuple[list[Toolkit], list[BaseTool]]:
         """Split toolkits into executable tools and request middleware tools."""
 
         executable_toolkits: list[Toolkit] = []
-        middleware: list[MCPConnectorTool] = []
+        middleware: list[BaseTool] = []
 
         for toolkit in toolkits:
             executable_tools: list[Tool] = []
@@ -387,6 +394,8 @@ class AnthropicMessagesAdapter(LLMAdapter[dict]):
                 elif isinstance(t, Tool):
                     executable_tools.append(t)
                 elif isinstance(t, BaseTool):
+                    if hasattr(t, "apply") and callable(getattr(t, "apply")):
+                        middleware.append(t)
                     # Non-executable tool types are ignored.
                     continue
                 else:
@@ -407,10 +416,17 @@ class AnthropicMessagesAdapter(LLMAdapter[dict]):
         return executable_toolkits, middleware
 
     def _apply_request_middleware(
-        self, *, request: dict, middleware: list[MCPConnectorTool]
+        self, *, request: dict, middleware: list[BaseTool]
     ) -> dict:
+        headers = request.get("extra_headers") or {}
         for m in middleware:
-            m.apply(request=request)
+            apply = getattr(m, "apply", None)
+            if callable(apply):
+                try:
+                    apply(request=request, headers=headers)
+                except TypeError:
+                    apply(request=request)
+        request["extra_headers"] = headers or None
         return request
 
     async def next(
@@ -551,6 +567,10 @@ class AnthropicMessagesAdapter(LLMAdapter[dict]):
                                 response=tool_response,
                             )
                         except Exception as ex:
+                            logger.error(
+                                f"error in tool call {tool_use.get('name')}:",
+                                exc_info=ex,
+                            )
                             tool_result_content = [_text_block(f"Error: {ex}")]
                             message = {
                                 "role": "user",

meshagent/anthropic/openai_responses_stream_adapter.py

@@ -114,7 +114,11 @@ class AnthropicOpenAIResponsesStreamAdapter(AnthropicMessagesAdapter):
 
         async with client.messages.stream(**request) as stream:
             async for event in stream:
-                data = event.model_dump(mode="json")
+                data = event.model_dump(
+                    mode="json",
+                    exclude_none=True,
+                    exclude_unset=True,
+                )
                 etype = data.get("type")
 
                 if etype == "message_start":
@@ -356,7 +360,11 @@ class AnthropicOpenAIResponsesStreamAdapter(AnthropicMessagesAdapter):
                     continue
 
         final_message = await stream.get_final_message()
-        final_dict = final_message.model_dump(mode="json")
+        final_dict = final_message.model_dump(
+            mode="json",
+            exclude_none=True,
+            exclude_unset=True,
+        )
         usage = final_dict.get("usage") or {}
         input_tokens = usage.get("input_tokens")
         output_tokens = usage.get("output_tokens")

meshagent/anthropic/request_tool.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from meshagent.tools import BaseTool
+
+
+class AnthropicRequestTool(BaseTool):
+    beta_header = "anthropic-beta"
+
+    @staticmethod
+    def apply_betas(*, headers: dict, betas: Optional[list[str]]) -> None:
+        if not betas:
+            return
+
+        existing = headers.get(AnthropicRequestTool.beta_header)
+        existing_betas: list[str] = []
+
+        if isinstance(existing, str):
+            existing_betas = [b.strip() for b in existing.split(",") if b.strip()]
+        elif isinstance(existing, list):
+            existing_betas = [str(b) for b in existing if str(b)]
+
+        for beta in betas:
+            if beta not in existing_betas:
+                existing_betas.append(beta)
+
+        headers[AnthropicRequestTool.beta_header] = ",".join(existing_betas)

meshagent/anthropic/tests/mcp_test.py

@@ -11,9 +11,10 @@ def test_mcp_tool_apply_injects_servers_toolsets_and_beta():
 
     tool = MCPTool(config=cfg)
     request: dict = {"tools": []}
-    tool.apply(request=request)
+    headers: dict = {}
+    tool.apply(request=request, headers=headers)
 
-    assert request["betas"] == ["mcp-client-2025-11-20"]
+    assert headers["anthropic-beta"] == "mcp-client-2025-11-20"
     assert request["mcp_servers"] == [
         {
             "type": "url",
@@ -45,14 +46,16 @@ def test_mcp_tool_apply_dedupes_servers_by_name_and_preserves_existing():
                 "authorization_token": "OLD",
             }
         ],
-        "betas": ["some-other-beta"],
     }
 
-    tool.apply(request=request)
+    headers: dict = {"anthropic-beta": "some-other-beta"}
+
+    tool.apply(request=request, headers=headers)
 
     # Keeps existing betas and appends MCP beta.
-    assert "some-other-beta" in request["betas"]
-    assert "mcp-client-2025-11-20" in request["betas"]
+    betas = {b.strip() for b in headers["anthropic-beta"].split(",") if b.strip()}
+    assert "some-other-beta" in betas
+    assert "mcp-client-2025-11-20" in betas
 
     # Dedupes by name; cfg overwrites the existing server entry.
     by_name = {s["name"]: s for s in request["mcp_servers"]}

meshagent/anthropic/version.py

@@ -1 +1 @@
-__version__ = "0.25.0"
+__version__ = "0.25.2"

meshagent/anthropic/web_fetch.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from typing import Literal, Optional
+
+from pydantic import BaseModel, Field
+
+from meshagent.tools import Toolkit, ToolkitBuilder, ToolkitConfig
+
+from .request_tool import AnthropicRequestTool
+
+
+class WebFetchCitations(BaseModel):
+    enabled: bool = True
+
+
+class WebFetchConfig(ToolkitConfig):
+    name: Literal["web_fetch"] = "web_fetch"
+    max_uses: Optional[int] = None
+    allowed_domains: Optional[list[str]] = None
+    blocked_domains: Optional[list[str]] = None
+    citations: Optional[WebFetchCitations] = None
+    max_content_tokens: Optional[int] = None
+    betas: Optional[list[str]] = Field(default_factory=lambda: ["web-fetch-2025-09-10"])
+
+
+class WebFetchTool(AnthropicRequestTool):
+    def __init__(self, *, config: Optional[WebFetchConfig] = None):
+        if config is None:
+            config = WebFetchConfig(name="web_fetch")
+        super().__init__(name=config.name)
+        self.config = config
+
+    def apply(self, *, request: dict, headers: dict) -> None:
+        if self.config.allowed_domains and self.config.blocked_domains:
+            raise ValueError(
+                "web_fetch cannot set both allowed_domains and blocked_domains"
+            )
+
+        tools = request.setdefault("tools", [])
+        tool_def: dict[str, object] = {
+            "type": "web_fetch_20250910",
+            "name": self.config.name,
+        }
+        if self.config.max_uses is not None:
+            tool_def["max_uses"] = self.config.max_uses
+        if self.config.allowed_domains is not None:
+            tool_def["allowed_domains"] = self.config.allowed_domains
+        if self.config.blocked_domains is not None:
+            tool_def["blocked_domains"] = self.config.blocked_domains
+        if self.config.citations is not None:
+            tool_def["citations"] = self.config.citations.model_dump(
+                mode="json", exclude_none=True
+            )
+        if self.config.max_content_tokens is not None:
+            tool_def["max_content_tokens"] = self.config.max_content_tokens
+
+        if not any(
+            isinstance(t, dict)
+            and t.get("type") == tool_def["type"]
+            and t.get("name") == tool_def["name"]
+            for t in tools
+        ):
+            tools.append(tool_def)
+
+        self.apply_betas(headers=headers, betas=self.config.betas)
+
+
+class WebFetchToolkitBuilder(ToolkitBuilder):
+    def __init__(self):
+        super().__init__(name="web_fetch", type=WebFetchConfig)
+
+    async def make(self, *, room, model: str, config: WebFetchConfig) -> Toolkit:
+        return Toolkit(name="web_fetch", tools=[WebFetchTool(config=config)])

meshagent/anthropic/web_search.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from typing import Literal, Optional
+
+from pydantic import BaseModel
+
+from meshagent.tools import Toolkit, ToolkitBuilder, ToolkitConfig
+
+from .request_tool import AnthropicRequestTool
+
+
+class WebSearchConfig(ToolkitConfig):
+    name: Literal["web_search"] = "web_search"
+    max_uses: Optional[int] = None
+    allowed_domains: Optional[list[str]] = None
+    blocked_domains: Optional[list[str]] = None
+    user_location: Optional["WebSearchUserLocation"] = None
+    betas: Optional[list[str]] = None
+
+
+class WebSearchUserLocation(BaseModel):
+    type: Literal["approximate"] = "approximate"
+    city: Optional[str] = None
+    region: Optional[str] = None
+    country: Optional[str] = None
+    timezone: Optional[str] = None
+
+
+class WebSearchTool(AnthropicRequestTool):
+    def __init__(self, *, config: Optional[WebSearchConfig] = None):
+        if config is None:
+            config = WebSearchConfig(name="web_search")
+        super().__init__(name=config.name)
+        self.config = config
+
+    def apply(self, *, request: dict, headers: dict) -> None:
+        if self.config.allowed_domains and self.config.blocked_domains:
+            raise ValueError(
+                "web_search cannot set both allowed_domains and blocked_domains"
+            )
+
+        tools = request.setdefault("tools", [])
+        tool_def: dict[str, object] = {
+            "type": "web_search_20250305",
+            "name": self.config.name,
+        }
+        if self.config.max_uses is not None:
+            tool_def["max_uses"] = self.config.max_uses
+        if self.config.allowed_domains is not None:
+            tool_def["allowed_domains"] = self.config.allowed_domains
+        if self.config.blocked_domains is not None:
+            tool_def["blocked_domains"] = self.config.blocked_domains
+        if self.config.user_location is not None:
+            tool_def["user_location"] = self.config.user_location.model_dump(
+                mode="json", exclude_none=True
+            )
+        if not any(
+            isinstance(t, dict)
+            and t.get("type") == tool_def["type"]
+            and t.get("name") == tool_def["name"]
+            for t in tools
+        ):
+            tools.append(tool_def)
+
+        self.apply_betas(headers=headers, betas=self.config.betas)
+
+
+class WebSearchToolkitBuilder(ToolkitBuilder):
+    def __init__(self):
+        super().__init__(name="web_search", type=WebSearchConfig)
+
+    async def make(self, *, room, model: str, config: WebSearchConfig) -> Toolkit:
+        return Toolkit(name="web_search", tools=[WebSearchTool(config=config)])

{meshagent_anthropic-0.25.0.dist-info → meshagent_anthropic-0.25.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-anthropic
-Version: 0.25.0
+Version: 0.25.2
 Summary: Anthropic Building Blocks for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com
@@ -11,9 +11,9 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pytest~=8.4
 Requires-Dist: pytest-asyncio~=0.26
-Requires-Dist: meshagent-api~=0.25.0
-Requires-Dist: meshagent-agents~=0.25.0
-Requires-Dist: meshagent-tools~=0.25.0
+Requires-Dist: meshagent-api~=0.25.2
+Requires-Dist: meshagent-agents~=0.25.2
+Requires-Dist: meshagent-tools~=0.25.2
 Requires-Dist: anthropic<1.0,>=0.25
 Dynamic: license-file
 

meshagent_anthropic-0.25.2.dist-info/RECORD

@@ -0,0 +1,19 @@
+meshagent/anthropic/__init__.py,sha256=Pnh3_HRESWLfL_ntR3Jjt5oSuWwEHMJkTRBPH69hA-M,833
+meshagent/anthropic/mcp.py,sha256=KdH5r8Eu_3bWTttV-mNTgFBkAuf3fvaDWWXmTO93kLs,3148
+meshagent/anthropic/messages_adapter.py,sha256=cgD7P3eXIQTI5i_RUwe7adolWzJHw0umGjqL6Py-XbQ,24882
+meshagent/anthropic/openai_responses_stream_adapter.py,sha256=Pxn6LjMKzZJrFwxtDiMKunVaOxQ3pgWfjHODhuBdSTU,15967
+meshagent/anthropic/request_tool.py,sha256=053qqtkLhcugsI3AQjpt4AzMRQE-SC4szI4P5usAd1s,839
+meshagent/anthropic/version.py,sha256=NMzPG-AisbqV0qHNDcM-oIMtdXA6rLhjzeATPyNq6Nw,23
+meshagent/anthropic/web_fetch.py,sha256=jKOq3Hcyqm0q_CsQdPzXHXHhyBI8VBbXj-ZowjKCiRI,2637
+meshagent/anthropic/web_search.py,sha256=1ua9G9cIeZMOM-sQnIUYXlW54g_fc6edcxDA0o4srM0,2600
+meshagent/anthropic/proxy/__init__.py,sha256=_E4wvJC90tmMnatDodkD0kIB8zsDZ4_zFd-5s86WQ8c,106
+meshagent/anthropic/proxy/proxy.py,sha256=nQ_P2c3GWAbfQswlc11DTyIRJzZWaOm1Wg08HpCTl_k,2827
+meshagent/anthropic/tests/anthropic_live_test.py,sha256=t8Uy8za0He4p4oXhnVFAx6vsuCVcFFthtwsiN-AwVT0,4571
+meshagent/anthropic/tests/mcp_test.py,sha256=Su2GTHYN8ntNNhmmmnMKS5iDgJIuKKDJQT8Or_8LQO0,2286
+meshagent/anthropic/tests/messages_adapter_test.py,sha256=BQV1zOB1xM1-wRuGyvmIdeMhubmgmZH_1-tQLFXZLi8,5265
+meshagent/anthropic/tests/openai_responses_stream_adapter_test.py,sha256=WLkF5wSRYKV83n3GgIDoKI4EQdNJS6_EqC1_7RlMNHs,2842
+meshagent_anthropic-0.25.2.dist-info/licenses/LICENSE,sha256=TRD-XzqhdrBbIpokiGa61wuDTBc_ElKoFP9HSNihODc,10255
+meshagent_anthropic-0.25.2.dist-info/METADATA,sha256=sTdyJ5hsSdFzeXyEHON4WZfFxmedBQbdAAo7srrpY9s,1595
+meshagent_anthropic-0.25.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+meshagent_anthropic-0.25.2.dist-info/top_level.txt,sha256=GlcXnHtRP6m7zlG3Df04M35OsHtNXy_DY09oFwWrH74,10
+meshagent_anthropic-0.25.2.dist-info/RECORD,,

meshagent_anthropic-0.25.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-meshagent/anthropic/__init__.py,sha256=2VOFYIp1DY2ed8YfstSB1kV8n7hSX72v8d7gapm9INE,542
-meshagent/anthropic/mcp.py,sha256=9yDMOPo9wihMmPIpQUKXdAYDPTkZmCfRuW-OyWVPvLA,3218
-meshagent/anthropic/messages_adapter.py,sha256=WzVXpCWkrl5-fVM8PAAMSULQdy5wwB1ClQUy7AZpexk,24037
-meshagent/anthropic/openai_responses_stream_adapter.py,sha256=ODtWusjnPDNedE_Nx5dTdEAhihpWmAXyEbYHuF42D8M,15763
-meshagent/anthropic/version.py,sha256=Mu4JbSLl5nr-J2figk5hmW2mrw4skf_oeIzxbnpcgwY,23
-meshagent/anthropic/proxy/__init__.py,sha256=_E4wvJC90tmMnatDodkD0kIB8zsDZ4_zFd-5s86WQ8c,106
-meshagent/anthropic/proxy/proxy.py,sha256=nQ_P2c3GWAbfQswlc11DTyIRJzZWaOm1Wg08HpCTl_k,2827
-meshagent/anthropic/tests/anthropic_live_test.py,sha256=t8Uy8za0He4p4oXhnVFAx6vsuCVcFFthtwsiN-AwVT0,4571
-meshagent/anthropic/tests/mcp_test.py,sha256=fT_dDiBNMraGOLtUuu2F4q3Yf4QPfZN-ypZq2iZTQoc,2140
-meshagent/anthropic/tests/messages_adapter_test.py,sha256=BQV1zOB1xM1-wRuGyvmIdeMhubmgmZH_1-tQLFXZLi8,5265
-meshagent/anthropic/tests/openai_responses_stream_adapter_test.py,sha256=WLkF5wSRYKV83n3GgIDoKI4EQdNJS6_EqC1_7RlMNHs,2842
-meshagent_anthropic-0.25.0.dist-info/licenses/LICENSE,sha256=TRD-XzqhdrBbIpokiGa61wuDTBc_ElKoFP9HSNihODc,10255
-meshagent_anthropic-0.25.0.dist-info/METADATA,sha256=LYlzAbqznIxpqzTsC1VtqZkhXkoKj7xBogG5xOCFWkg,1595
-meshagent_anthropic-0.25.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-meshagent_anthropic-0.25.0.dist-info/top_level.txt,sha256=GlcXnHtRP6m7zlG3Df04M35OsHtNXy_DY09oFwWrH74,10
-meshagent_anthropic-0.25.0.dist-info/RECORD,,