meshagent-anthropic 0.21.0__py3-none-any.whl

meshagent/anthropic/__init__.py

@@ -0,0 +1,13 @@
+from .tools import (
+    AnthropicMessagesAdapter,
+    AnthropicMessagesToolResponseAdapter,
+    AnthropicOpenAIResponsesStreamAdapter,
+)
+from .version import __version__
+
+__all__ = [
+    __version__,
+    AnthropicMessagesAdapter,
+    AnthropicMessagesToolResponseAdapter,
+    AnthropicOpenAIResponsesStreamAdapter,
+]

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 = 4000) -> 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/tools/__init__.py

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

meshagent/anthropic/tools/messages_adapter.py

@@ -0,0 +1,419 @@
+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.api.messaging import (
+    Response,
+    LinkResponse,
+    FileResponse,
+    JsonResponse,
+    TextResponse,
+    EmptyResponse,
+    RawOutputs,
+    ensure_response,
+)
+from meshagent.agents.adapter import ToolResponseAdapter, LLMAdapter
+
+import json
+from typing import Any, Optional, Callable
+import os
+import logging
+import re
+import asyncio
+
+from meshagent.anthropic.proxy import get_client, get_logging_httpx_client
+
+try:
+    from anthropic import APIStatusError
+except Exception:  # pragma: no cover
+    APIStatusError = Exception  # type: ignore
+
+logger = logging.getLogger("anthropic_agent")
+
+
+def _replace_non_matching(text: str, allowed_chars: str, replacement: str) -> str:
+    pattern = rf"[^{allowed_chars}]"
+    return re.sub(pattern, replacement, text)
+
+
+def safe_tool_name(name: str) -> str:
+    return _replace_non_matching(name, "a-zA-Z0-9_-", "_")
+
+
+def _as_jsonable(obj: Any) -> Any:
+    if isinstance(obj, dict):
+        return obj
+    return obj.model_dump(mode="json")
+
+
+def _text_block(text: str) -> dict:
+    return {"type": "text", "text": text}
+
+
+class MessagesToolBundle:
+    def __init__(self, toolkits: list[Toolkit]):
+        self._executors: dict[str, Toolkit] = {}
+        self._safe_names: dict[str, str] = {}
+        self._tools_by_safe_name: dict[str, Tool] = {}
+
+        tools: list[dict] = []
+
+        for toolkit in toolkits:
+            for v in toolkit.tools:
+                if not isinstance(v, Tool):
+                    raise RoomException(f"unsupported tool type {type(v)}")
+
+                original_name = v.name
+                safe_name = safe_tool_name(original_name)
+
+                if original_name in self._executors:
+                    raise Exception(
+                        f"duplicate in bundle '{original_name}', tool names must be unique."
+                    )
+
+                self._executors[original_name] = toolkit
+                self._safe_names[safe_name] = original_name
+                self._tools_by_safe_name[safe_name] = v
+
+                schema = {**v.input_schema}
+                if v.defs is not None:
+                    schema["$defs"] = v.defs
+
+                tools.append(
+                    {
+                        "name": safe_name,
+                        "description": v.description,
+                        "input_schema": schema,
+                    }
+                )
+
+        self._tools = tools or None
+
+    def to_json(self) -> list[dict] | None:
+        return None if self._tools is None else self._tools.copy()
+
+    def get_tool(self, safe_name: str) -> Tool | None:
+        return self._tools_by_safe_name.get(safe_name)
+
+    async def execute(self, *, context: ToolContext, tool_use: dict) -> Response:
+        safe_name = tool_use.get("name")
+        if safe_name not in self._safe_names:
+            raise RoomException(
+                f"Invalid tool name {safe_name}, check the name of the tool"
+            )
+
+        name = self._safe_names[safe_name]
+        if name not in self._executors:
+            raise Exception(f"Unregistered tool name {name}")
+
+        arguments = tool_use.get("input") or {}
+        proxy = self._executors[name]
+        result = await proxy.execute(context=context, name=name, arguments=arguments)
+        return ensure_response(result)
+
+
+class AnthropicMessagesToolResponseAdapter(ToolResponseAdapter):
+    async def to_plain_text(self, *, room: RoomClient, response: Response) -> str:
+        if isinstance(response, LinkResponse):
+            return json.dumps({"name": response.name, "url": response.url})
+        if isinstance(response, JsonResponse):
+            return json.dumps(response.json)
+        if isinstance(response, TextResponse):
+            return response.text
+        if isinstance(response, FileResponse):
+            return response.name
+        if isinstance(response, EmptyResponse):
+            return "ok"
+        if isinstance(response, dict):
+            return json.dumps(response)
+        if isinstance(response, str):
+            return response
+        if response is None:
+            return "ok"
+        raise Exception("unexpected return type: {type}".format(type=type(response)))
+
+    async def create_messages(
+        self,
+        *,
+        context: AgentChatContext,
+        tool_call: Any,
+        room: RoomClient,
+        response: Response,
+    ) -> list:
+        tool_use = tool_call if isinstance(tool_call, dict) else _as_jsonable(tool_call)
+        tool_use_id = tool_use.get("id")
+        if tool_use_id is None:
+            raise RoomException("anthropic tool_use block was missing an id")
+
+        if isinstance(response, RawOutputs):
+            # 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)
+
+        message = {
+            "role": "user",
+            "content": [
+                {
+                    "type": "tool_result",
+                    "tool_use_id": tool_use_id,
+                    "content": [_text_block(output)],
+                }
+            ],
+        }
+
+        room.developer.log_nowait(
+            type="llm.message",
+            data={
+                "context": context.id,
+                "participant_id": room.local_participant.id,
+                "participant_name": room.local_participant.get_attribute("name"),
+                "message": message,
+            },
+        )
+
+        return [message]
+
+
+class AnthropicMessagesAdapter(LLMAdapter[dict]):
+    def __init__(
+        self,
+        model: str = os.getenv("ANTHROPIC_MODEL", "claude-3-5-sonnet-latest"),
+        max_tokens: int = int(os.getenv("ANTHROPIC_MAX_TOKENS", "1024")),
+        client: Optional[Any] = None,
+        message_options: Optional[dict] = None,
+        provider: str = "anthropic",
+        log_requests: bool = False,
+    ):
+        self._model = model
+        self._max_tokens = max_tokens
+        self._client = client
+        self._message_options = message_options or {}
+        self._provider = provider
+        self._log_requests = log_requests
+
+    def default_model(self) -> str:
+        return self._model
+
+    def create_chat_context(self) -> AgentChatContext:
+        return AgentChatContext(system_role=None)
+
+    def get_anthropic_client(self, *, room: RoomClient) -> Any:
+        if self._client is not None:
+            return self._client
+        http_client = get_logging_httpx_client() if self._log_requests else None
+        return get_client(room=room, http_client=http_client)
+
+    def _convert_messages(
+        self, *, context: AgentChatContext
+    ) -> tuple[list[dict], Optional[str]]:
+        system = context.get_system_instructions()
+
+        messages: list[dict] = []
+        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)]}
+                    )
+                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))]}
+                    )
+
+        return messages, system
+
+    async def _create_with_optional_headers(self, client: Any, **kwargs) -> Any:
+        try:
+            return await client.messages.create(**kwargs)
+        except TypeError:
+            kwargs.pop("extra_headers", None)
+            return await client.messages.create(**kwargs)
+
+    async def _stream_message(
+        self,
+        *,
+        client: Any,
+        request: dict,
+        event_handler: Callable[[dict], None],
+    ) -> Any:
+        """Stream text deltas and return the final message.
+
+        Uses the official Anthropic SDK streaming helper:
+
+        ```py
+        async with client.messages.stream(...) as stream:
+            async for text in stream.text_stream:
+                ...
+        message = await stream.get_final_message()
+        ```
+        """
+
+        stream = client.messages.stream(**request)
+
+        async with stream:
+            async for event in stream:
+                event_handler({"type": event.type, "event": _as_jsonable(event)})
+
+        final_message = await stream.get_final_message()
+        event_handler(
+            {"type": "message.completed", "message": _as_jsonable(final_message)}
+        )
+        return final_message
+
+    async def next(
+        self,
+        *,
+        context: AgentChatContext,
+        room: RoomClient,
+        toolkits: list[Toolkit],
+        tool_adapter: Optional[ToolResponseAdapter] = None,
+        output_schema: Optional[dict] = None,
+        event_handler: Optional[Callable[[dict], None]] = None,
+        model: Optional[str] = None,
+        on_behalf_of: Optional[RemoteParticipant] = None,
+    ) -> Any:
+        if model is None:
+            model = self.default_model()
+
+        if tool_adapter is None:
+            tool_adapter = AnthropicMessagesToolResponseAdapter()
+
+        client = self.get_anthropic_client(room=room)
+
+        validation_attempts = 0
+
+        try:
+            while True:
+                tool_bundle = MessagesToolBundle(toolkits=toolkits)
+                tools = tool_bundle.to_json()
+
+                messages, system = self._convert_messages(context=context)
+
+                if output_schema is not None:
+                    schema_hint = json.dumps(output_schema)
+                    schema_system = (
+                        "Return ONLY valid JSON that matches this JSON Schema. "
+                        "Do not wrap in markdown. Schema: " + schema_hint
+                    )
+                    system = (
+                        (system + "\n" + schema_system) if system else schema_system
+                    )
+
+                extra_headers = {}
+                if on_behalf_of is not None:
+                    extra_headers["Meshagent-On-Behalf-Of"] = (
+                        on_behalf_of.get_attribute("name")
+                    )
+
+                request = {
+                    "model": model,
+                    "max_tokens": self._max_tokens,
+                    "messages": messages,
+                    "system": system,
+                    "tools": tools,
+                    "extra_headers": extra_headers or None,
+                    **(self._message_options or {}),
+                }
+
+                # remove None fields
+                request = {k: v for k, v in request.items() if v is not None}
+
+                logger.info("requesting response from anthropic with model: %s", model)
+
+                if event_handler is not None:
+                    final_message = await self._stream_message(
+                        client=client,
+                        request=request,
+                        event_handler=event_handler,
+                    )
+                    response_dict = _as_jsonable(final_message)
+                else:
+                    response = await self._create_with_optional_headers(
+                        client, **request
+                    )
+                    response_dict = _as_jsonable(response)
+
+                content_blocks = []
+                raw_content = response_dict.get("content")
+                if isinstance(raw_content, list):
+                    content_blocks = raw_content
+
+                tool_uses = [b for b in content_blocks if b.get("type") == "tool_use"]
+
+                # Keep the assistant message in context.
+                assistant_message = {"role": "assistant", "content": content_blocks}
+                context.messages.append(assistant_message)
+
+                if tool_uses:
+                    tasks = []
+
+                    async def do_tool(tool_use: dict) -> list[dict]:
+                        tool_context = ToolContext(
+                            room=room,
+                            caller=room.local_participant,
+                            on_behalf_of=on_behalf_of,
+                            caller_context={"chat": context.to_json()},
+                        )
+                        tool_response = await tool_bundle.execute(
+                            context=tool_context,
+                            tool_use=tool_use,
+                        )
+                        return await tool_adapter.create_messages(
+                            context=context,
+                            tool_call=tool_use,
+                            room=room,
+                            response=tool_response,
+                        )
+
+                    for tool_use in tool_uses:
+                        tasks.append(asyncio.create_task(do_tool(tool_use)))
+
+                    results = await asyncio.gather(*tasks)
+                    for msgs in results:
+                        for msg in msgs:
+                            context.messages.append(msg)
+
+                    continue
+
+                # no tool calls; return final content
+                text = "".join(
+                    [
+                        b.get("text", "")
+                        for b in content_blocks
+                        if b.get("type") == "text"
+                    ]
+                )
+
+                if output_schema is None:
+                    return text
+
+                # Schema-mode: parse and validate JSON.
+                validation_attempts += 1
+                try:
+                    parsed = json.loads(text)
+                    self.validate(response=parsed, output_schema=output_schema)
+                    return parsed
+                except Exception as e:
+                    if validation_attempts >= 3:
+                        raise RoomException(
+                            f"Invalid JSON response from Anthropic: {e}"
+                        )
+                    context.messages.append(
+                        {
+                            "role": "user",
+                            "content": (
+                                "The previous response did not match the required JSON schema. "
+                                f"Error: {e}. Please try again and return only valid JSON."
+                            ),
+                        }
+                    )
+
+        except APIStatusError as e:
+            raise RoomException(f"Error from Anthropic: {e}")

meshagent/anthropic/tools/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/version.py

@@ -0,0 +1 @@
+__version__ = "0.21.0"

meshagent_anthropic-0.21.0.dist-info/METADATA

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: meshagent-anthropic
+Version: 0.21.0
+Summary: Anthropic Building Blocks for Meshagent
+License-Expression: Apache-2.0
+Project-URL: Documentation, https://docs.meshagent.com
+Project-URL: Website, https://www.meshagent.com
+Project-URL: Source, https://www.meshagent.com
+Requires-Python: >=3.13
+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: anthropic<1.0,>=0.25
+Dynamic: license-file
+
+# [Meshagent](https://www.meshagent.com)
+
+## MeshAgent Anthropic
+The `meshagent.anthropic` package provides adapters to integrate Anthropic models (Messages API) with MeshAgent tools and agents.
+
+### Messages Adapter
+- `AnthropicMessagesAdapter`: wraps the Anthropic Messages API. It turns `Toolkit` objects into Anthropic tool definitions, executes tool calls, and returns the final assistant response.
+
+```Python Python
+from meshagent.anthropic import AnthropicMessagesAdapter
+
+adapter = AnthropicMessagesAdapter(model="claude-3-5-sonnet-latest")
+```
+
+### Tool Response Adapter
+`AnthropicMessagesToolResponseAdapter` converts a tool's structured response into Anthropic `tool_result` blocks that can be inserted back into the conversation.
+
+---
+### Learn more about MeshAgent on our website or check out the docs for additional examples!
+
+**Website**: [www.meshagent.com](https://www.meshagent.com/)
+
+**Documentation**: [docs.meshagent.com](https://docs.meshagent.com/)
+
+---

meshagent_anthropic-0.21.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+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,,

meshagent_anthropic-0.21.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

meshagent_anthropic-0.21.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction,
+and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by
+the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all
+other entities that control, are controlled by, or are under common
+control with that entity. For the purposes of this definition,
+"control" means (i) the power, direct or indirect, to cause the
+direction or management of such entity, whether by contract or
+otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity
+exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications,
+including but not limited to software source code, documentation
+source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical
+transformation or translation of a Source form, including but
+not limited to compiled object code, generated documentation,
+and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or
+Object form, made available under the License, as indicated by a
+copyright notice that is included in or attached to the work
+(an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object
+form, that is based on (or derived from) the Work and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship. For the purposes
+of this License, Derivative Works shall not include works that remain
+separable from, or merely link (or bind by name) to the interfaces of,
+the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including
+the original version of the Work and any modifications or additions
+to that Work or Derivative Works thereof, that is intentionally
+submitted to Licensor for inclusion in the Work by the copyright owner
+or by an individual or Legal Entity authorized to submit on behalf of
+the copyright owner. For the purposes of this definition, "submitted"
+means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems,
+and issue tracking systems that are managed by, or on behalf of, the
+Licensor for the purpose of discussing and improving the Work, but
+excluding communication that is conspicuously marked or otherwise
+designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity
+on behalf of whom a Contribution has been received by Licensor and
+subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the
+Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+(except as stated in this section) patent license to make, have made,
+use, offer to sell, sell, import, and otherwise transfer the Work,
+where such license applies only to those patent claims licensable
+by such Contributor that are necessarily infringed by their
+Contribution(s) alone or by combination of their Contribution(s)
+with the Work to which such Contribution(s) was submitted. If You
+institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work
+or a Contribution incorporated within the Work constitutes direct
+or contributory patent infringement, then any patent licenses
+granted to You under this License for that Work shall terminate
+as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+Work or Derivative Works thereof in any medium, with or without
+modifications, and in Source or Object form, provided that You
+meet the following conditions:
+
+(a) You must give any other recipients of the Work or
+Derivative Works a copy of this License; and
+
+(b) You must cause any modified files to carry prominent notices
+stating that You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works
+that You distribute, all copyright, patent, trademark, and
+attribution notices from the Source form of the Work,
+excluding those notices that do not pertain to any part of
+the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its
+distribution, then any Derivative Works that You distribute must
+include a readable copy of the attribution notices contained
+within such NOTICE file, excluding those notices that do not
+pertain to any part of the Derivative Works, in at least one
+of the following places: within a NOTICE text file distributed
+as part of the Derivative Works; within the Source form or
+documentation, if provided along with the Derivative Works; or,
+within a display generated by the Derivative Works, if and
+wherever such third-party notices normally appear. The contents
+of the NOTICE file are for informational purposes only and
+do not modify the License. You may add Your own attribution
+notices within Derivative Works that You distribute, alongside
+or as an addendum to the NOTICE text from the Work, provided
+that such additional attribution notices cannot be construed
+as modifying the License.
+
+You may add Your own copyright statement to Your modifications and
+may provide additional or different license terms and conditions
+for use, reproduction, or distribution of Your modifications, or
+for any such Derivative Works as a whole, provided Your use,
+reproduction, and distribution of the Work otherwise complies with
+the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+any Contribution intentionally submitted for inclusion in the Work
+by You to the Licensor shall be under the terms and conditions of
+this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify
+the terms of any separate license agreement you may have executed
+with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+names, trademarks, service marks, or product names of the Licensor,
+except as required for reasonable and customary use in describing the
+origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+agreed to in writing, Licensor provides the Work (and each
+Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied, including, without limitation, any warranties or conditions
+of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+PARTICULAR PURPOSE. You are solely responsible for determining the
+appropriateness of using or redistributing the Work and assume any
+risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+whether in tort (including negligence), contract, or otherwise,
+unless required by applicable law (such as deliberate and grossly
+negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special,
+incidental, or consequential damages of any character arising as a
+result of this License or out of the use or inability to use the
+Work (including but not limited to damages for loss of goodwill,
+work stoppage, computer failure or malfunction, or any and all
+other commercial damages or losses), even if such Contributor
+has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+the Work or Derivative Works thereof, You may choose to offer,
+and charge a fee for, acceptance of support, warranty, indemnity,
+or other liability obligations and/or rights consistent with this
+License. However, in accepting such obligations, You may act only
+on Your own behalf and on Your sole responsibility, not on behalf
+of any other Contributor, and only if You agree to indemnify,
+defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason
+of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+To apply the Apache License to your work, attach the following
+boilerplate notice, with the fields enclosed by brackets "[]"
+replaced with your own identifying information. (Don't include
+the brackets!)  The text should be enclosed in the appropriate
+comment syntax for the file format. We also recommend that a
+file or class name and description of purpose be included on the
+same "printed page" as the copyright notice for easier
+identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

meshagent_anthropic-0.21.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+meshagent