meshagent-anthropic 0.23.0__py3-none-any.whl

meshagent/anthropic/openai_responses_stream_adapter.py

@@ -0,0 +1,400 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import Any, Callable, Optional
+
+from meshagent.api import RoomClient, RemoteParticipant
+from meshagent.agents.agent import AgentChatContext
+from meshagent.tools import Toolkit
+
+from .messages_adapter import AnthropicMessagesAdapter
+
+
+@dataclass
+class _OutputBlockState:
+    kind: str  # "message" | "function_call" | "reasoning"
+    item_id: str
+    output_index: int
+    content_index: int
+    name: Optional[str] = None
+    call_id: Optional[str] = None
+    text: str = ""
+    arguments: str = ""
+
+
+class AnthropicOpenAIResponsesStreamAdapter(AnthropicMessagesAdapter):
+    """Anthropic adapter that emits OpenAI Responses-style stream events.
+
+    This is useful when you have downstream consumers that already understand the
+    OpenAI Responses streaming event schema (e.g. UI code), but want to run the
+    underlying inference on Anthropic.
+
+    Notes:
+    - This adapter only affects the *streaming* event shape.
+    - Tool execution still uses MeshAgent toolkits and the Anthropic tool loop.
+    """
+
+    async def _stream_message(
+        self,
+        *,
+        client: Any,
+        request: dict,
+        event_handler: Callable[[dict], None],
+    ) -> Any:
+        seq = 0
+        response_id: Optional[str] = None
+        response_model: str = str(request.get("model"))
+
+        output: list[dict] = []
+        blocks: dict[int, _OutputBlockState] = {}
+
+        created_at = int(time.time())
+
+        def emit(payload: dict) -> None:
+            nonlocal seq
+            if "sequence_number" not in payload:
+                payload["sequence_number"] = seq
+            seq += 1
+            event_handler(payload)
+
+        def output_message_item(*, item_id: str, status: str, text: str) -> dict:
+            return {
+                "type": "message",
+                "id": item_id,
+                "role": "assistant",
+                "status": status,
+                "content": [
+                    {
+                        "type": "output_text",
+                        "text": text,
+                        "annotations": [],
+                        "logprobs": None,
+                    }
+                ],
+            }
+
+        def output_function_call_item(
+            *,
+            item_id: str,
+            call_id: str,
+            name: str,
+            status: Optional[str],
+            arguments: str,
+        ) -> dict:
+            return {
+                "type": "function_call",
+                "id": item_id,
+                "call_id": call_id,
+                "name": name,
+                "arguments": arguments,
+                "status": status,
+            }
+
+        def output_reasoning_item(*, item_id: str, status: str, text: str) -> dict:
+            return {
+                "type": "reasoning",
+                "id": item_id,
+                "status": status,
+                "summary": [],
+                "content": [{"type": "reasoning_text", "text": text}],
+                "encrypted_content": None,
+            }
+
+        response_obj: dict = {
+            "id": None,
+            "object": "response",
+            "created_at": created_at,
+            "model": response_model,
+            "output": output,
+            "status": "in_progress",
+            "error": None,
+            "usage": None,
+        }
+
+        async with client.messages.stream(**request) as stream:
+            async for event in stream:
+                data = event.model_dump(mode="json")
+                etype = data.get("type")
+
+                if etype == "message_start":
+                    message = data.get("message") or {}
+                    response_id = message.get("id") or response_id
+                    response_obj["id"] = response_id
+                    if message.get("model") is not None:
+                        response_obj["model"] = message.get("model")
+
+                    emit({"type": "response.created", "response": dict(response_obj)})
+
+                elif etype == "content_block_start":
+                    idx = int(data.get("index"))
+                    block = data.get("content_block") or {}
+                    btype = block.get("type")
+
+                    output_index = len(output)
+                    base_item_id = response_id or "anthropic"
+                    item_id = f"{base_item_id}_out_{output_index}"
+
+                    if btype == "text":
+                        item = output_message_item(
+                            item_id=item_id, status="in_progress", text=""
+                        )
+                        output.append(item)
+                        blocks[idx] = _OutputBlockState(
+                            kind="message",
+                            item_id=item_id,
+                            output_index=output_index,
+                            content_index=0,
+                        )
+
+                    elif btype == "tool_use":
+                        call_id = str(block.get("id"))
+                        name = str(block.get("name"))
+                        item = output_function_call_item(
+                            item_id=item_id,
+                            call_id=call_id,
+                            name=name,
+                            status="in_progress",
+                            arguments="",
+                        )
+                        output.append(item)
+                        blocks[idx] = _OutputBlockState(
+                            kind="function_call",
+                            item_id=item_id,
+                            output_index=output_index,
+                            content_index=0,
+                            name=name,
+                            call_id=call_id,
+                        )
+
+                    elif btype == "thinking":
+                        item = output_reasoning_item(
+                            item_id=item_id, status="in_progress", text=""
+                        )
+                        output.append(item)
+                        blocks[idx] = _OutputBlockState(
+                            kind="reasoning",
+                            item_id=item_id,
+                            output_index=output_index,
+                            content_index=0,
+                        )
+
+                    else:
+                        # Unknown block type: ignore for OpenAI compatibility.
+                        continue
+
+                    emit(
+                        {
+                            "type": "response.output_item.added",
+                            "output_index": output_index,
+                            "item": output[output_index],
+                        }
+                    )
+
+                    # OpenAI-style content part events (text + reasoning content).
+                    state = blocks.get(idx)
+                    if state is not None and state.kind in {"message", "reasoning"}:
+                        emit(
+                            {
+                                "type": "response.content_part.added",
+                                "output_index": state.output_index,
+                                "item_id": state.item_id,
+                                "content_index": state.content_index,
+                                "part": output[state.output_index]["content"][
+                                    state.content_index
+                                ],
+                            }
+                        )
+
+                elif etype == "content_block_delta":
+                    idx = int(data.get("index"))
+                    state = blocks.get(idx)
+                    if state is None:
+                        continue
+
+                    delta = data.get("delta") or {}
+                    dtype = delta.get("type")
+
+                    if dtype == "text_delta" and state.kind == "message":
+                        piece = str(delta.get("text") or "")
+                        state.text += piece
+                        output[state.output_index]["content"][0]["text"] = state.text
+
+                        emit(
+                            {
+                                "type": "response.output_text.delta",
+                                "output_index": state.output_index,
+                                "item_id": state.item_id,
+                                "content_index": state.content_index,
+                                "delta": piece,
+                                "logprobs": None,
+                            }
+                        )
+
+                    elif dtype == "input_json_delta" and state.kind == "function_call":
+                        piece = str(delta.get("partial_json") or "")
+                        state.arguments += piece
+                        output[state.output_index]["arguments"] = state.arguments
+
+                        emit(
+                            {
+                                "type": "response.function_call_arguments.delta",
+                                "output_index": state.output_index,
+                                "item_id": state.item_id,
+                                "delta": piece,
+                            }
+                        )
+
+                    elif dtype == "thinking_delta" and state.kind == "reasoning":
+                        piece = str(delta.get("thinking") or "")
+                        state.text += piece
+                        output[state.output_index]["content"][0]["text"] = state.text
+
+                        emit(
+                            {
+                                "type": "response.reasoning_text.delta",
+                                "output_index": state.output_index,
+                                "item_id": state.item_id,
+                                "content_index": state.content_index,
+                                "delta": piece,
+                            }
+                        )
+
+                    else:
+                        # Ignore signature_delta and unknown deltas.
+                        continue
+
+                elif etype == "content_block_stop":
+                    idx = int(data.get("index"))
+                    state = blocks.get(idx)
+                    if state is None:
+                        continue
+
+                    if state.kind == "message":
+                        emit(
+                            {
+                                "type": "response.output_text.done",
+                                "output_index": state.output_index,
+                                "item_id": state.item_id,
+                                "content_index": state.content_index,
+                                "text": state.text,
+                                "logprobs": None,
+                            }
+                        )
+                        output[state.output_index] = output_message_item(
+                            item_id=state.item_id, status="completed", text=state.text
+                        )
+                        emit(
+                            {
+                                "type": "response.content_part.done",
+                                "output_index": state.output_index,
+                                "item_id": state.item_id,
+                                "content_index": state.content_index,
+                                "part": output[state.output_index]["content"][
+                                    state.content_index
+                                ],
+                            }
+                        )
+
+                    elif state.kind == "function_call":
+                        emit(
+                            {
+                                "type": "response.function_call_arguments.done",
+                                "output_index": state.output_index,
+                                "item_id": state.item_id,
+                                "name": state.name,
+                                "arguments": state.arguments,
+                            }
+                        )
+                        output[state.output_index] = output_function_call_item(
+                            item_id=state.item_id,
+                            call_id=str(state.call_id),
+                            name=str(state.name),
+                            status="completed",
+                            arguments=state.arguments,
+                        )
+
+                    elif state.kind == "reasoning":
+                        emit(
+                            {
+                                "type": "response.reasoning_text.done",
+                                "output_index": state.output_index,
+                                "item_id": state.item_id,
+                                "content_index": state.content_index,
+                                "text": state.text,
+                            }
+                        )
+                        output[state.output_index] = output_reasoning_item(
+                            item_id=state.item_id, status="completed", text=state.text
+                        )
+                        emit(
+                            {
+                                "type": "response.content_part.done",
+                                "output_index": state.output_index,
+                                "item_id": state.item_id,
+                                "content_index": state.content_index,
+                                "part": output[state.output_index]["content"][
+                                    state.content_index
+                                ],
+                            }
+                        )
+
+                    emit(
+                        {
+                            "type": "response.output_item.done",
+                            "output_index": state.output_index,
+                            "item": output[state.output_index],
+                        }
+                    )
+
+                elif etype == "message_stop":
+                    # Defer `response.completed` until after we have final usage.
+                    pass
+
+                else:
+                    # ping, message_delta, etc.
+                    continue
+
+        final_message = await stream.get_final_message()
+        final_dict = final_message.model_dump(mode="json")
+        usage = final_dict.get("usage") or {}
+        input_tokens = usage.get("input_tokens")
+        output_tokens = usage.get("output_tokens")
+        if isinstance(input_tokens, int) and isinstance(output_tokens, int):
+            response_obj["usage"] = {
+                "input_tokens": input_tokens,
+                "output_tokens": output_tokens,
+                "total_tokens": input_tokens + output_tokens,
+                "input_tokens_details": None,
+                "output_tokens_details": None,
+            }
+
+        response_obj["status"] = "completed"
+        response_obj["output"] = output
+
+        emit({"type": "response.completed", "response": dict(response_obj)})
+        return final_message
+
+    async def next(
+        self,
+        *,
+        context: AgentChatContext,
+        room: RoomClient,
+        toolkits: list[Toolkit],
+        tool_adapter: Any = None,
+        output_schema: Optional[dict] = None,
+        event_handler: Optional[Callable[[dict], None]] = None,
+        model: Optional[str] = None,
+        on_behalf_of: Optional[RemoteParticipant] = None,
+    ) -> Any:
+        # Keep the same behavior; only streaming shape changes.
+        return await super().next(
+            context=context,
+            room=room,
+            toolkits=toolkits,
+            tool_adapter=tool_adapter,
+            output_schema=output_schema,
+            event_handler=event_handler,
+            model=model,
+            on_behalf_of=on_behalf_of,
+        )

meshagent/anthropic/proxy/__init__.py

@@ -0,0 +1,3 @@
+from .proxy import get_client, get_logging_httpx_client
+
+__all__ = [get_client, get_logging_httpx_client]

meshagent/anthropic/proxy/proxy.py

@@ -0,0 +1,90 @@
+from meshagent.api import RoomClient
+import logging
+import json
+import httpx
+from typing import Optional, Any
+
+try:
+    from anthropic import AsyncAnthropic
+except Exception:  # pragma: no cover
+    AsyncAnthropic = None  # type: ignore
+
+logger = logging.getLogger("anthropic.client")
+
+
+def _redact_headers(headers: httpx.Headers) -> dict:
+    h = dict(headers)
+    if "x-api-key" in {k.lower() for k in h.keys()}:
+        for k in list(h.keys()):
+            if k.lower() == "x-api-key":
+                h[k] = "***REDACTED***"
+    if "authorization" in {k.lower() for k in h.keys()}:
+        for k in list(h.keys()):
+            if k.lower() == "authorization":
+                h[k] = "***REDACTED***"
+    return h
+
+
+def _truncate_bytes(b: bytes, limit: int = 1024 * 100) -> str:
+    s = b.decode("utf-8", errors="replace")
+    return (
+        s
+        if len(s) <= limit
+        else (s[:limit] + f"\n... (truncated, {len(s)} chars total)")
+    )
+
+
+async def log_request(request: httpx.Request):
+    logging.info("==> %s %s", request.method, request.url)
+    logging.info("headers=%s", json.dumps(_redact_headers(request.headers), indent=2))
+    if request.content:
+        logging.info("body=%s", _truncate_bytes(request.content))
+
+
+async def log_response(response: httpx.Response):
+    body = await response.aread()
+    logging.info("<== %s %s", response.status_code, response.request.url)
+    logging.info("headers=%s", json.dumps(_redact_headers(response.headers), indent=2))
+    if body:
+        logging.info("body=%s", _truncate_bytes(body))
+
+
+def get_logging_httpx_client() -> httpx.AsyncClient:
+    return httpx.AsyncClient(
+        event_hooks={"request": [log_request], "response": [log_response]},
+        timeout=60.0,
+    )
+
+
+def get_client(
+    *, room: RoomClient, http_client: Optional[httpx.AsyncClient] = None
+) -> Any:
+    if AsyncAnthropic is None:  # pragma: no cover
+        raise RuntimeError(
+            "anthropic is not installed. Install `meshagent-anthropic` extras/deps."
+        )
+
+    token: str = room.protocol.token
+
+    url = getattr(room.protocol, "url")
+    if url is None:
+        logger.debug(
+            "protocol does not have url, anthropic client falling back to room url %s",
+            room.room_url,
+        )
+        url = room.room_url
+    else:
+        logger.debug("protocol had url, anthropic client will use %s", url)
+
+    room_proxy_url = f"{url}/anthropic"
+
+    if room_proxy_url.startswith("ws:") or room_proxy_url.startswith("wss:"):
+        room_proxy_url = room_proxy_url.replace("ws", "http", 1)
+
+    # The MeshAgent room proxy validates `x-api-key` and `Meshagent-Session`.
+    return AsyncAnthropic(
+        api_key=token,
+        base_url=room_proxy_url,
+        http_client=http_client,
+        default_headers={"Meshagent-Session": room.session_id},
+    )

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