meshagent-anthropic 0.21.0__py3-none-any.whl → 0.22.0__py3-none-any.whl

meshagent/anthropic/__init__.py

@@ -1,13 +1,25 @@
-from .tools import (
+from .messages_adapter import (
     AnthropicMessagesAdapter,
     AnthropicMessagesToolResponseAdapter,
-    AnthropicOpenAIResponsesStreamAdapter,
 )
-from .version import __version__
+from .mcp import (
+    MCPConfig,
+    MCPServer,
+    MCPTool,
+    MCPToolConfig,
+    MCPToolset,
+    MCPToolkitBuilder,
+)
+from .openai_responses_stream_adapter import AnthropicOpenAIResponsesStreamAdapter
 
 __all__ = [
-    __version__,
     AnthropicMessagesAdapter,
     AnthropicMessagesToolResponseAdapter,
     AnthropicOpenAIResponsesStreamAdapter,
+    MCPConfig,
+    MCPServer,
+    MCPTool,
+    MCPToolConfig,
+    MCPToolset,
+    MCPToolkitBuilder,
 ]

meshagent/anthropic/mcp.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from typing import Literal, Optional
+
+from pydantic import BaseModel
+
+from meshagent.tools import BaseTool, Toolkit, ToolkitBuilder, ToolkitConfig
+
+
+# This module wraps Anthropic's official MCP connector support:
+# https://platform.claude.com/docs/en/agents-and-tools/mcp-connector
+
+
+MCP_CONNECTOR_BETA = "mcp-client-2025-11-20"
+
+
+class MCPServer(BaseModel):
+    """Anthropic `mcp_servers` entry."""
+
+    type: Literal["url"] = "url"
+    url: str
+    name: str
+    authorization_token: Optional[str] = None
+
+
+class MCPToolConfig(BaseModel):
+    enabled: Optional[bool] = None
+    defer_loading: Optional[bool] = None
+
+
+class MCPToolset(BaseModel):
+    """Anthropic `tools` entry for MCP connector."""
+
+    type: Literal["mcp_toolset"] = "mcp_toolset"
+    mcp_server_name: str
+    default_config: Optional[MCPToolConfig] = None
+    configs: Optional[dict[str, MCPToolConfig]] = None
+
+    # Pass-through cache control, if desired.
+    cache_control: Optional[dict] = None
+
+
+class MCPConfig(ToolkitConfig):
+    """MeshAgent toolkit config that injects MCP connector params.
+
+    This is intentionally modeled after the OpenAI adapter's MCP config pattern
+    (a toolkit config that can be provided via `tools=[...]` in chat messages),
+    but it produces Anthropic-specific request parameters: `mcp_servers` and
+    `mcp_toolset` entries.
+    """
+
+    name: Literal["mcp"] = "mcp"
+
+    mcp_servers: list[MCPServer]
+    toolsets: Optional[list[MCPToolset]] = None
+    betas: list[str] = [MCP_CONNECTOR_BETA]
+
+
+class MCPTool(BaseTool):
+    """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:
+        """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)
+
+        toolsets = self.config.toolsets
+        if toolsets is None:
+            toolsets = [
+                MCPToolset(mcp_server_name=s.name) for s in self.config.mcp_servers
+            ]
+
+        # Merge/dedupe servers by name.
+        existing_servers = request.setdefault("mcp_servers", [])
+        dedup: dict[str, dict] = {
+            s["name"]: s
+            for s in existing_servers
+            if isinstance(s, dict) and isinstance(s.get("name"), str)
+        }
+        for server in self.config.mcp_servers:
+            dedup[server.name] = server.model_dump(mode="json", exclude_none=True)
+        request["mcp_servers"] = list(dedup.values())
+
+        # Anthropic MCP toolsets live inside the top-level `tools` array.
+        tools = request.setdefault("tools", [])
+        for toolset in toolsets:
+            tools.append(toolset.model_dump(mode="json", exclude_none=True))
+
+
+class MCPToolkitBuilder(ToolkitBuilder):
+    def __init__(self):
+        super().__init__(name="mcp", type=MCPConfig)
+
+    async def make(self, *, room, model: str, config: MCPConfig) -> Toolkit:
+        return Toolkit(name="mcp", tools=[MCPTool(config=config)])

meshagent/anthropic/{tools/messages_adapter.py → messages_adapter.py}

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from meshagent.agents.agent import AgentChatContext
 from meshagent.api import RoomClient, RoomException, RemoteParticipant
-from meshagent.tools import Toolkit, ToolContext, Tool
+from meshagent.tools import Toolkit, ToolContext, Tool, BaseTool
 from meshagent.api.messaging import (
     Response,
     LinkResponse,
@@ -21,8 +21,10 @@ import os
 import logging
 import re
 import asyncio
+import base64
 
 from meshagent.anthropic.proxy import get_client, get_logging_httpx_client
+from meshagent.anthropic.mcp import MCPTool as MCPConnectorTool
 
 try:
     from anthropic import APIStatusError
@@ -150,7 +152,51 @@ class AnthropicMessagesToolResponseAdapter(ToolResponseAdapter):
             # Allow advanced tools to return pre-built Anthropic blocks.
             return [{"role": "user", "content": response.outputs}]
 
-        output = await self.to_plain_text(room=room, response=response)
+        tool_result_content: list[dict]
+
+        if isinstance(response, FileResponse):
+            mime_type = (response.mime_type or "").lower()
+
+            if mime_type == "image/jpg":
+                mime_type = "image/jpeg"
+
+            if mime_type.startswith("image/"):
+                allowed = {"image/jpeg", "image/png", "image/gif", "image/webp"}
+                if mime_type not in allowed:
+                    output = f"{response.name} was returned as {response.mime_type}, which Anthropic does not accept as an image block"
+                    tool_result_content = [_text_block(output)]
+                else:
+                    tool_result_content = [
+                        {
+                            "type": "image",
+                            "source": {
+                                "type": "base64",
+                                "media_type": mime_type,
+                                "data": base64.b64encode(response.data).decode("utf-8"),
+                            },
+                        }
+                    ]
+
+            elif mime_type == "application/pdf":
+                tool_result_content = [
+                    {
+                        "type": "document",
+                        "title": response.name,
+                        "source": {
+                            "type": "base64",
+                            "media_type": "application/pdf",
+                            "data": base64.b64encode(response.data).decode("utf-8"),
+                        },
+                    }
+                ]
+
+            else:
+                output = await self.to_plain_text(room=room, response=response)
+                tool_result_content = [_text_block(output)]
+
+        else:
+            output = await self.to_plain_text(room=room, response=response)
+            tool_result_content = [_text_block(output)]
 
         message = {
             "role": "user",
@@ -158,7 +204,7 @@ class AnthropicMessagesToolResponseAdapter(ToolResponseAdapter):
                 {
                     "type": "tool_result",
                     "tool_use_id": tool_use_id,
-                    "content": [_text_block(output)],
+                    "content": tool_result_content,
                 }
             ],
         }
@@ -210,31 +256,81 @@ class AnthropicMessagesAdapter(LLMAdapter[dict]):
     ) -> tuple[list[dict], Optional[str]]:
         system = context.get_system_instructions()
 
+        def as_blocks(role: str, content: Any) -> dict:
+            if isinstance(content, str):
+                return {"role": role, "content": [_text_block(content)]}
+            if isinstance(content, list):
+                return {"role": role, "content": content}
+            return {"role": role, "content": [_text_block(str(content))]}
+
         messages: list[dict] = []
+        pending_tool_use_ids: set[str] = set()
+
         for m in context.messages:
-            if m.get("role") in {"user", "assistant"}:
-                content = m.get("content")
-                if isinstance(content, str):
-                    messages.append(
-                        {"role": m["role"], "content": [_text_block(content)]}
+            role = m.get("role")
+            if role not in {"user", "assistant"}:
+                continue
+
+            msg = as_blocks(role, m.get("content"))
+
+            # Anthropic requires that tool_result blocks appear in the *immediately next*
+            # user message after an assistant tool_use.
+            if pending_tool_use_ids:
+                if role == "assistant":
+                    # Drop any assistant chatter that appears between tool_use and tool_result.
+                    logger.warning(
+                        "dropping assistant message between tool_use and tool_result"
                     )
-                elif isinstance(content, list):
-                    # Allow passing through OpenAI-style image/file blocks if already present.
-                    # Tool adapters will also insert Anthropic blocks here.
-                    messages.append({"role": m["role"], "content": content})
-                else:
-                    messages.append(
-                        {"role": m["role"], "content": [_text_block(str(content))]}
+                    continue
+
+                # role == user
+                content_blocks = msg.get("content") or []
+                tool_results = [
+                    b
+                    for b in content_blocks
+                    if isinstance(b, dict) and b.get("type") == "tool_result"
+                ]
+                tool_result_ids = {
+                    b.get("tool_use_id") for b in tool_results if b.get("tool_use_id")
+                }
+
+                if not pending_tool_use_ids.issubset(tool_result_ids):
+                    # If we can't satisfy the ordering contract, it's better to fail early
+                    # with a clear error than to send an invalid request.
+                    raise RoomException(
+                        "invalid transcript: tool_use blocks must be followed by a user message "
+                        "containing tool_result blocks for all tool_use ids"
                     )
 
+                pending_tool_use_ids.clear()
+
+            # Track tool_use ids introduced by assistant messages.
+            if role == "assistant":
+                content_blocks = msg.get("content") or []
+                for b in content_blocks:
+                    if isinstance(b, dict) and b.get("type") == "tool_use":
+                        tool_id = b.get("id")
+                        if tool_id:
+                            pending_tool_use_ids.add(tool_id)
+
+            messages.append(msg)
+
         return messages, system
 
-    async def _create_with_optional_headers(self, client: Any, **kwargs) -> Any:
+    def _messages_api(self, *, client: Any, request: dict) -> Any:
+        # The MCP connector requires `client.beta.messages.*`.
+        if request.get("betas") is not None:
+            return client.beta.messages
+        return client.messages
+
+    async def _create_with_optional_headers(self, *, client: Any, request: dict) -> Any:
+        api = self._messages_api(client=client, request=request)
         try:
-            return await client.messages.create(**kwargs)
+            return await api.create(**request)
         except TypeError:
-            kwargs.pop("extra_headers", None)
-            return await client.messages.create(**kwargs)
+            request = dict(request)
+            request.pop("extra_headers", None)
+            return await api.create(**request)
 
     async def _stream_message(
         self,
@@ -255,9 +351,10 @@ class AnthropicMessagesAdapter(LLMAdapter[dict]):
         ```
         """
 
-        stream = client.messages.stream(**request)
+        api = self._messages_api(client=client, request=request)
+        stream_mgr = api.stream(**request)
 
-        async with stream:
+        async with stream_mgr as stream:
             async for event in stream:
                 event_handler({"type": event.type, "event": _as_jsonable(event)})
 
@@ -267,6 +364,49 @@ class AnthropicMessagesAdapter(LLMAdapter[dict]):
         )
         return final_message
 
+    def _split_toolkits(
+        self, *, toolkits: list[Toolkit]
+    ) -> tuple[list[Toolkit], list[MCPConnectorTool]]:
+        """Split toolkits into executable tools and request middleware tools."""
+
+        executable_toolkits: list[Toolkit] = []
+        middleware: list[MCPConnectorTool] = []
+
+        for toolkit in toolkits:
+            executable_tools: list[Tool] = []
+
+            for t in toolkit.tools:
+                if isinstance(t, MCPConnectorTool):
+                    middleware.append(t)
+                elif isinstance(t, Tool):
+                    executable_tools.append(t)
+                elif isinstance(t, BaseTool):
+                    # Non-executable tool types are ignored.
+                    continue
+                else:
+                    raise RoomException(f"unsupported tool type {type(t)}")
+
+            if executable_tools:
+                executable_toolkits.append(
+                    Toolkit(
+                        name=toolkit.name,
+                        title=getattr(toolkit, "title", None),
+                        description=getattr(toolkit, "description", None),
+                        thumbnail_url=getattr(toolkit, "thumbnail_url", None),
+                        rules=getattr(toolkit, "rules", []),
+                        tools=executable_tools,
+                    )
+                )
+
+        return executable_toolkits, middleware
+
+    def _apply_request_middleware(
+        self, *, request: dict, middleware: list[MCPConnectorTool]
+    ) -> dict:
+        for m in middleware:
+            m.apply(request=request)
+        return request
+
     async def next(
         self,
         *,
@@ -291,8 +431,10 @@ class AnthropicMessagesAdapter(LLMAdapter[dict]):
 
         try:
             while True:
-                tool_bundle = MessagesToolBundle(toolkits=toolkits)
-                tools = tool_bundle.to_json()
+                executable_toolkits, middleware = self._split_toolkits(
+                    toolkits=toolkits
+                )
+                tool_bundle = MessagesToolBundle(toolkits=executable_toolkits)
 
                 messages, system = self._convert_messages(context=context)
 
@@ -312,16 +454,45 @@ class AnthropicMessagesAdapter(LLMAdapter[dict]):
                         on_behalf_of.get_attribute("name")
                     )
 
+                message_options = dict(self._message_options or {})
+
+                tools_list: list[dict] = tool_bundle.to_json() or []
+                extra_tools = message_options.pop("tools", None)
+                if isinstance(extra_tools, list):
+                    tools_list.extend(extra_tools)
+
                 request = {
                     "model": model,
                     "max_tokens": self._max_tokens,
                     "messages": messages,
                     "system": system,
-                    "tools": tools,
+                    "tools": tools_list,
                     "extra_headers": extra_headers or None,
-                    **(self._message_options or {}),
+                    **message_options,
                 }
 
+                request = self._apply_request_middleware(
+                    request=request,
+                    middleware=middleware,
+                )
+
+                # Normalize empty lists to None for Anthropic.
+                if (
+                    isinstance(request.get("tools"), list)
+                    and len(request["tools"]) == 0
+                ):
+                    request["tools"] = None
+                if (
+                    isinstance(request.get("mcp_servers"), list)
+                    and len(request["mcp_servers"]) == 0
+                ):
+                    request["mcp_servers"] = None
+                if (
+                    isinstance(request.get("betas"), list)
+                    and len(request["betas"]) == 0
+                ):
+                    request["betas"] = None
+
                 # remove None fields
                 request = {k: v for k, v in request.items() if v is not None}
 
@@ -336,7 +507,8 @@ class AnthropicMessagesAdapter(LLMAdapter[dict]):
                     response_dict = _as_jsonable(final_message)
                 else:
                     response = await self._create_with_optional_headers(
-                        client, **request
+                        client=client,
+                        request=request,
                     )
                     response_dict = _as_jsonable(response)
 
@@ -376,9 +548,35 @@ class AnthropicMessagesAdapter(LLMAdapter[dict]):
                         tasks.append(asyncio.create_task(do_tool(tool_use)))
 
                     results = await asyncio.gather(*tasks)
+
+                    # Anthropic requires tool_result blocks for *all* tool_use ids to appear in the
+                    # *immediately next* user message after the assistant tool_use message.
+                    tool_result_blocks: list[dict] = []
+                    trailing_messages: list[dict] = []
+
                     for msgs in results:
                         for msg in msgs:
-                            context.messages.append(msg)
+                            if (
+                                isinstance(msg, dict)
+                                and msg.get("role") == "user"
+                                and isinstance(msg.get("content"), list)
+                                and all(
+                                    isinstance(b, dict)
+                                    and b.get("type") == "tool_result"
+                                    for b in msg["content"]
+                                )
+                            ):
+                                tool_result_blocks.extend(msg["content"])
+                            else:
+                                trailing_messages.append(msg)
+
+                    if tool_result_blocks:
+                        context.messages.append(
+                            {"role": "user", "content": tool_result_blocks}
+                        )
+
+                    for msg in trailing_messages:
+                        context.messages.append(msg)
 
                     continue
 

meshagent/anthropic/proxy/proxy.py

@@ -25,7 +25,7 @@ def _redact_headers(headers: httpx.Headers) -> dict:
     return h
 
 
-def _truncate_bytes(b: bytes, limit: int = 4000) -> str:
+def _truncate_bytes(b: bytes, limit: int = 1024 * 100) -> str:
     s = b.decode("utf-8", errors="replace")
     return (
         s

meshagent/anthropic/tests/anthropic_live_test.py

@@ -0,0 +1,156 @@
+import os
+import sys
+
+import pytest
+
+from meshagent.anthropic.messages_adapter import AnthropicMessagesAdapter
+from meshagent.anthropic.mcp import MCPConfig, MCPServer, MCPTool
+from meshagent.agents.agent import AgentChatContext
+from meshagent.tools import Toolkit
+
+
+def _import_real_anthropic_sdk():
+    """Import the external `anthropic` SDK without shadowing.
+
+    If `pytest` is run from inside `.../meshagent/`, Python may resolve
+    `import anthropic` to the local `meshagent/anthropic` package directory.
+    """
+
+    cwd = os.getcwd()
+
+    if os.path.isdir(os.path.join(cwd, "anthropic")):
+        sys.path = [p for p in sys.path if p not in ("", cwd)]
+
+    import importlib
+
+    mod = importlib.import_module("anthropic")
+
+    mod_file = getattr(mod, "__file__", "") or ""
+    if mod_file.endswith("/meshagent/anthropic/__init__.py"):
+        raise RuntimeError(
+            "Imported local `meshagent/anthropic` instead of the Anthropic SDK. "
+            "Run pytest from the repo root."
+        )
+
+    return mod
+
+
+a = _import_real_anthropic_sdk()
+
+
+class _DummyRoom:
+    # Adapter won't touch room when no tools.
+    pass
+
+
+@pytest.mark.asyncio
+async def test_live_anthropic_adapter_messages_create_if_key_set():
+    api_key = os.getenv("ANTHROPIC_API_KEY")
+    if not api_key:
+        pytest.skip("ANTHROPIC_API_KEY not set")
+
+    model = os.getenv("ANTHROPIC_TEST_MODEL", "claude-sonnet-4-5")
+
+    client = a.AsyncAnthropic(api_key=api_key)
+    adapter = AnthropicMessagesAdapter(model=model, client=client, max_tokens=64)
+
+    ctx = AgentChatContext(system_role=None)
+    ctx.append_user_message("Say hello in one word.")
+
+    text = await adapter.next(context=ctx, room=_DummyRoom(), toolkits=[])
+
+    assert isinstance(text, str)
+    assert len(text.strip()) > 0
+
+
+@pytest.mark.asyncio
+async def test_live_anthropic_adapter_streaming_if_key_set():
+    api_key = os.getenv("ANTHROPIC_API_KEY")
+    if not api_key:
+        pytest.skip("ANTHROPIC_API_KEY not set")
+
+    model = os.getenv("ANTHROPIC_TEST_MODEL", "claude-sonnet-4-5")
+
+    client = a.AsyncAnthropic(api_key=api_key)
+    adapter = AnthropicMessagesAdapter(model=model, client=client, max_tokens=64)
+
+    ctx = AgentChatContext(system_role=None)
+    ctx.append_user_message("Count from 1 to 3.")
+
+    seen_types: list[str] = []
+
+    def handler(event: dict):
+        if isinstance(event, dict) and "type" in event:
+            seen_types.append(event["type"])
+
+    text = await adapter.next(
+        context=ctx,
+        room=_DummyRoom(),
+        toolkits=[],
+        event_handler=handler,
+    )
+
+    assert isinstance(text, str)
+    assert len(text.strip()) > 0
+    # These are best-effort; event types depend on Anthropic SDK.
+    assert len(seen_types) > 0
+
+
+@pytest.mark.asyncio
+async def test_live_anthropic_mcp_deepwiki_if_key_set():
+    api_key = os.getenv("ANTHROPIC_API_KEY")
+    if not api_key:
+        pytest.skip("ANTHROPIC_API_KEY not set")
+
+    model = os.getenv("ANTHROPIC_TEST_MODEL", "claude-sonnet-4-5")
+
+    client = a.AsyncAnthropic(api_key=api_key)
+    adapter = AnthropicMessagesAdapter(model=model, client=client, max_tokens=256)
+
+    ctx = AgentChatContext(system_role=None)
+    ctx.append_user_message(
+        "Use the DeepWiki MCP toolset and make at least one tool call. "
+        "Then reply with a one-sentence summary of what you learned."
+    )
+
+    mcp_toolkit = Toolkit(
+        name="mcp",
+        tools=[
+            MCPTool(
+                config=MCPConfig(
+                    mcp_servers=[
+                        MCPServer(url="https://mcp.deepwiki.com/mcp", name="deepwiki")
+                    ]
+                )
+            )
+        ],
+    )
+
+    seen_mcp_blocks = False
+
+    def handler(event: dict):
+        nonlocal seen_mcp_blocks
+        if not isinstance(event, dict):
+            return
+
+        # Adapter forwards Anthropic SDK stream events:
+        # {"type": "content_block_start", "event": {...}}
+        if event.get("type") == "content_block_start":
+            payload = event.get("event") or {}
+            content_block = payload.get("content_block") or {}
+            if content_block.get("type") in {"mcp_tool_use", "mcp_tool_result"}:
+                seen_mcp_blocks = True
+
+    text = await adapter.next(
+        context=ctx,
+        room=_DummyRoom(),
+        toolkits=[mcp_toolkit],
+        event_handler=handler,
+    )
+
+    assert isinstance(text, str)
+    assert len(text.strip()) > 0
+
+    # This asserts the connector actually engaged (best-effort, but should be stable
+    # for DeepWiki).
+    assert seen_mcp_blocks

meshagent/anthropic/tests/mcp_test.py

@@ -0,0 +1,64 @@
+from meshagent.anthropic.mcp import MCPConfig, MCPServer, MCPTool, MCPToolset
+
+
+def test_mcp_tool_apply_injects_servers_toolsets_and_beta():
+    cfg = MCPConfig(
+        mcp_servers=[
+            MCPServer(url="https://mcp.example.com/sse", name="example-mcp"),
+        ],
+        toolsets=[MCPToolset(mcp_server_name="example-mcp")],
+    )
+
+    tool = MCPTool(config=cfg)
+    request: dict = {"tools": []}
+    tool.apply(request=request)
+
+    assert request["betas"] == ["mcp-client-2025-11-20"]
+    assert request["mcp_servers"] == [
+        {
+            "type": "url",
+            "url": "https://mcp.example.com/sse",
+            "name": "example-mcp",
+        }
+    ]
+
+    assert request["tools"][0]["type"] == "mcp_toolset"
+    assert request["tools"][0]["mcp_server_name"] == "example-mcp"
+
+
+def test_mcp_tool_apply_dedupes_servers_by_name_and_preserves_existing():
+    cfg = MCPConfig(
+        mcp_servers=[
+            MCPServer(url="https://mcp.example.com/sse", name="example-mcp"),
+            MCPServer(url="https://mcp.other.com/sse", name="other"),
+        ]
+    )
+    tool = MCPTool(config=cfg)
+
+    request: dict = {
+        "tools": [{"type": "tool", "name": "some_tool"}],
+        "mcp_servers": [
+            {
+                "type": "url",
+                "url": "https://old.example.com/sse",
+                "name": "example-mcp",
+                "authorization_token": "OLD",
+            }
+        ],
+        "betas": ["some-other-beta"],
+    }
+
+    tool.apply(request=request)
+
+    # Keeps existing betas and appends MCP beta.
+    assert "some-other-beta" in request["betas"]
+    assert "mcp-client-2025-11-20" in request["betas"]
+
+    # Dedupes by name; cfg overwrites the existing server entry.
+    by_name = {s["name"]: s for s in request["mcp_servers"]}
+    assert set(by_name.keys()) == {"example-mcp", "other"}
+    assert by_name["example-mcp"]["url"] == "https://mcp.example.com/sse"
+
+    # If toolsets omitted, it creates one per server.
+    mcp_toolsets = [t for t in request["tools"] if t.get("type") == "mcp_toolset"]
+    assert {t["mcp_server_name"] for t in mcp_toolsets} == {"example-mcp", "other"}

meshagent/anthropic/tests/messages_adapter_test.py

@@ -0,0 +1,179 @@
+import pytest
+
+from meshagent.anthropic.messages_adapter import AnthropicMessagesAdapter
+from meshagent.agents.agent import AgentChatContext
+from meshagent.tools import Tool, Toolkit
+from meshagent.api import RoomException
+from meshagent.agents.adapter import ToolResponseAdapter
+
+
+class _DummyParticipant:
+    def __init__(self):
+        self.id = "p1"
+
+    def get_attribute(self, name: str):
+        if name == "name":
+            return "tester"
+        return None
+
+
+class _DummyRoom:
+    def __init__(self):
+        self.local_participant = _DummyParticipant()
+
+
+class _AnyArgsTool(Tool):
+    def __init__(self, name: str):
+        super().__init__(
+            name=name,
+            input_schema={"type": "object", "additionalProperties": True},
+            description="test tool",
+        )
+
+    async def execute(self, context, **kwargs):
+        return {"ok": True, "args": kwargs}
+
+
+class _ToolResultAdapter(ToolResponseAdapter):
+    async def to_plain_text(self, *, room, response):
+        return "ok"
+
+    async def create_messages(self, *, context, tool_call, room, response):
+        return [
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "tool_result",
+                        "tool_use_id": tool_call["id"],
+                        "content": [{"type": "text", "text": "ok"}],
+                    }
+                ],
+            }
+        ]
+
+
+class _FakeAdapter(AnthropicMessagesAdapter):
+    def __init__(self, responses: list[dict]):
+        super().__init__(client=object())
+        self._responses = responses
+        self._idx = 0
+
+    async def _create_with_optional_headers(self, *, client, request):
+        if self._idx >= len(self._responses):
+            raise AssertionError("unexpected extra request")
+        resp = self._responses[self._idx]
+        self._idx += 1
+        return resp
+
+
+def test_convert_messages_drops_assistant_between_tool_use_and_tool_result():
+    ctx = AgentChatContext(
+        system_role=None,
+        messages=[
+            {"role": "user", "content": "hi"},
+            {
+                "role": "assistant",
+                "content": [
+                    {"type": "text", "text": "calling tool"},
+                    {
+                        "type": "tool_use",
+                        "id": "toolu_1",
+                        "name": "tool_a",
+                        "input": {},
+                    },
+                ],
+            },
+            {"role": "assistant", "content": "stray assistant message"},
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "tool_result",
+                        "tool_use_id": "toolu_1",
+                        "content": [{"type": "text", "text": "ok"}],
+                    }
+                ],
+            },
+        ],
+    )
+
+    adapter = AnthropicMessagesAdapter(client=object())
+    msgs, _system = adapter._convert_messages(context=ctx)
+
+    assert [m["role"] for m in msgs] == ["user", "assistant", "user"]
+    assert msgs[1]["content"][1]["type"] == "tool_use"
+
+
+def test_convert_messages_raises_if_tool_result_not_immediately_next():
+    ctx = AgentChatContext(
+        system_role=None,
+        messages=[
+            {"role": "user", "content": "hi"},
+            {
+                "role": "assistant",
+                "content": [
+                    {
+                        "type": "tool_use",
+                        "id": "toolu_1",
+                        "name": "tool_a",
+                        "input": {},
+                    },
+                ],
+            },
+            {"role": "user", "content": "not a tool_result"},
+        ],
+    )
+
+    adapter = AnthropicMessagesAdapter(client=object())
+
+    with pytest.raises(RoomException):
+        adapter._convert_messages(context=ctx)
+
+
+@pytest.mark.asyncio
+async def test_next_batches_multiple_tool_results_into_single_user_message():
+    responses = [
+        {
+            "content": [
+                {"type": "text", "text": "calling tools"},
+                {"type": "tool_use", "id": "toolu_1", "name": "tool_a", "input": {}},
+                {"type": "tool_use", "id": "toolu_2", "name": "tool_b", "input": {}},
+            ]
+        },
+        {"content": [{"type": "text", "text": "done"}]},
+    ]
+
+    adapter = _FakeAdapter(responses=responses)
+    ctx = AgentChatContext(system_role=None)
+    ctx.append_user_message("run tools")
+
+    toolkit = Toolkit(
+        name="test",
+        tools=[_AnyArgsTool("tool_a"), _AnyArgsTool("tool_b")],
+    )
+
+    result = await adapter.next(
+        context=ctx,
+        room=_DummyRoom(),
+        toolkits=[toolkit],
+        tool_adapter=_ToolResultAdapter(),
+    )
+
+    assert result == "done"
+
+    # Expect: user -> assistant(tool_use) -> user(tool_results batched) -> assistant(final)
+    assert [m["role"] for m in ctx.messages] == [
+        "user",
+        "assistant",
+        "user",
+        "assistant",
+    ]
+
+    tool_results_msg = ctx.messages[2]
+    assert tool_results_msg["role"] == "user"
+    assert len(tool_results_msg["content"]) == 2
+    assert {b["tool_use_id"] for b in tool_results_msg["content"]} == {
+        "toolu_1",
+        "toolu_2",
+    }

meshagent/anthropic/tests/openai_responses_stream_adapter_test.py

@@ -0,0 +1,102 @@
+import pytest
+from pydantic import BaseModel
+
+from meshagent.anthropic.openai_responses_stream_adapter import (
+    AnthropicOpenAIResponsesStreamAdapter,
+)
+
+
+class _Event(BaseModel):
+    type: str
+    index: int | None = None
+    message: dict | None = None
+    content_block: dict | None = None
+    delta: dict | None = None
+
+
+class _FinalMessage(BaseModel):
+    id: str = "msg_1"
+    usage: dict = {"input_tokens": 3, "output_tokens": 5}
+
+
+class _FakeStream:
+    def __init__(self, events: list[BaseModel], final: BaseModel):
+        self._events = events
+        self._final = final
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        return False
+
+    def __aiter__(self):
+        async def gen():
+            for e in self._events:
+                yield e
+
+        return gen()
+
+    async def get_final_message(self):
+        return self._final
+
+
+class _FakeMessages:
+    def __init__(self, stream: _FakeStream):
+        self._stream = stream
+
+    def stream(self, **kwargs):
+        return self._stream
+
+
+class _FakeClient:
+    def __init__(self, stream: _FakeStream):
+        self.messages = _FakeMessages(stream)
+
+
+@pytest.mark.asyncio
+async def test_openai_responses_stream_emits_content_part_events():
+    events = [
+        _Event(type="message_start", message={"id": "msg_1", "model": "claude"}),
+        _Event(type="content_block_start", index=0, content_block={"type": "text"}),
+        _Event(
+            type="content_block_delta",
+            index=0,
+            delta={"type": "text_delta", "text": "hi"},
+        ),
+        _Event(type="content_block_stop", index=0),
+        _Event(type="message_stop"),
+    ]
+
+    stream = _FakeStream(events=events, final=_FinalMessage())
+    client = _FakeClient(stream)
+
+    adapter = AnthropicOpenAIResponsesStreamAdapter(client=client)
+
+    emitted: list[dict] = []
+
+    def handler(e: dict):
+        emitted.append(e)
+
+    await adapter._stream_message(
+        client=client,
+        request={"model": "x", "max_tokens": 5, "messages": []},
+        event_handler=handler,
+    )
+
+    types = [e["type"] for e in emitted]
+
+    assert "response.created" in types
+    assert "response.output_item.added" in types
+    assert "response.content_part.added" in types
+    assert "response.output_text.delta" in types
+    assert "response.output_text.done" in types
+    assert "response.content_part.done" in types
+    assert "response.output_item.done" in types
+    assert "response.completed" in types
+
+    # Sanity-check completed response contains usage.
+    completed = next(e for e in emitted if e["type"] == "response.completed")
+    assert completed["response"]["usage"]["input_tokens"] == 3
+    assert completed["response"]["usage"]["output_tokens"] == 5
+    assert completed["response"]["usage"]["total_tokens"] == 8

meshagent/anthropic/version.py

@@ -1 +1 @@
-__version__ = "0.21.0"
+__version__ = "0.22.0"

{meshagent_anthropic-0.21.0.dist-info → meshagent_anthropic-0.22.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-anthropic
-Version: 0.21.0
+Version: 0.22.0
 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.21.0
-Requires-Dist: meshagent-agents~=0.21.0
-Requires-Dist: meshagent-tools~=0.21.0
+Requires-Dist: meshagent-api~=0.22.0
+Requires-Dist: meshagent-agents~=0.22.0
+Requires-Dist: meshagent-tools~=0.22.0
 Requires-Dist: anthropic<1.0,>=0.25
 Dynamic: license-file
 

meshagent_anthropic-0.22.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+meshagent/anthropic/__init__.py,sha256=2VOFYIp1DY2ed8YfstSB1kV8n7hSX72v8d7gapm9INE,542
+meshagent/anthropic/mcp.py,sha256=9yDMOPo9wihMmPIpQUKXdAYDPTkZmCfRuW-OyWVPvLA,3218
+meshagent/anthropic/messages_adapter.py,sha256=6YWg75iBFqhsbAgl5oqy6a6BzXkoFAu3chFmOt58jk0,22895
+meshagent/anthropic/openai_responses_stream_adapter.py,sha256=ODtWusjnPDNedE_Nx5dTdEAhihpWmAXyEbYHuF42D8M,15763
+meshagent/anthropic/version.py,sha256=0kk8efeJF41FZIYweGTJylbizaWrp9W3qN78RClCWIU,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.22.0.dist-info/licenses/LICENSE,sha256=TRD-XzqhdrBbIpokiGa61wuDTBc_ElKoFP9HSNihODc,10255
+meshagent_anthropic-0.22.0.dist-info/METADATA,sha256=wnobcioGD5KijDIKd7xUaqkL9L8MsA2gD8NNP7QYSxI,1595
+meshagent_anthropic-0.22.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+meshagent_anthropic-0.22.0.dist-info/top_level.txt,sha256=GlcXnHtRP6m7zlG3Df04M35OsHtNXy_DY09oFwWrH74,10
+meshagent_anthropic-0.22.0.dist-info/RECORD,,

meshagent/anthropic/tools/__init__.py

@@ -1,11 +0,0 @@
-from .messages_adapter import (
-    AnthropicMessagesAdapter,
-    AnthropicMessagesToolResponseAdapter,
-)
-from .openai_responses_stream_adapter import AnthropicOpenAIResponsesStreamAdapter
-
-__all__ = [
-    AnthropicMessagesAdapter,
-    AnthropicMessagesToolResponseAdapter,
-    AnthropicOpenAIResponsesStreamAdapter,
-]

meshagent_anthropic-0.21.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-meshagent/anthropic/__init__.py,sha256=aQVq1WNkmJRwZiV9i7lF_K2MHrTyOSDe3ewuXU7FOEg,318
-meshagent/anthropic/version.py,sha256=-reNiXr25nUU7em7_IKJzimCI10W4nA8ouxAiOr4FaQ,23
-meshagent/anthropic/proxy/__init__.py,sha256=_E4wvJC90tmMnatDodkD0kIB8zsDZ4_zFd-5s86WQ8c,106
-meshagent/anthropic/proxy/proxy.py,sha256=FSVuTao0NyVQ6SVritDNFrL0bborUaMrXt2z-65Zk-4,2821
-meshagent/anthropic/tools/__init__.py,sha256=FwuQWhftwumt_GZJL20kHMBfvb6zpe1Vy6JaSOw6e9E,319
-meshagent/anthropic/tools/messages_adapter.py,sha256=28Op_g-nBD9yCP9wiXQCsxoktxf_J31Fzeyixqnpei4,14821
-meshagent/anthropic/tools/openai_responses_stream_adapter.py,sha256=ODtWusjnPDNedE_Nx5dTdEAhihpWmAXyEbYHuF42D8M,15763
-meshagent_anthropic-0.21.0.dist-info/licenses/LICENSE,sha256=TRD-XzqhdrBbIpokiGa61wuDTBc_ElKoFP9HSNihODc,10255
-meshagent_anthropic-0.21.0.dist-info/METADATA,sha256=RI1gurw9ovXk-yKc5Ij1n4pxASEYOIN5VI_GbQXwqDo,1595
-meshagent_anthropic-0.21.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-meshagent_anthropic-0.21.0.dist-info/top_level.txt,sha256=GlcXnHtRP6m7zlG3Df04M35OsHtNXy_DY09oFwWrH74,10
-meshagent_anthropic-0.21.0.dist-info/RECORD,,