dais-sdk 0.6.0__py3-none-any.whl

dais_sdk/mcp_client/remote_mcp_client.py

@@ -0,0 +1,157 @@
+import httpx
+import webbrowser
+from dataclasses import dataclass
+from contextlib import AsyncExitStack
+from typing import Any, NamedTuple
+from mcp import ClientSession
+from mcp.client.auth import OAuthClientProvider
+from mcp.client.streamable_http import streamable_http_client
+from mcp.shared.auth import OAuthClientMetadata
+from pydantic import AnyUrl, BaseModel, Field, ConfigDict, SkipValidation
+from .oauth_server import LocalOAuthServer, OAuthCode, TokenStorage, InMemoryTokenStorage
+from .base_mcp_client import McpClient, Tool, ToolResult, McpSessionNotEstablishedError
+from ..logger import logger
+
+@dataclass
+class OAuthParams:
+    oauth_scopes: list[str] | None = None
+    oauth_timeout: int = 120
+    oauth_token_storage: SkipValidation[TokenStorage] = Field(
+        default_factory=InMemoryTokenStorage,
+        exclude=True,
+    )
+
+class RemoteServerParams(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    url: str
+    bearer_token: str | None = None
+    oauth_params: OAuthParams | None = None
+    http_headers: dict[str, str] | None = None
+
+# --- --- --- --- --- ---
+
+class OAuthContext(NamedTuple):
+    client: httpx.AsyncClient
+    server: LocalOAuthServer
+
+class RemoteMcpClient(McpClient):
+    def __init__(self,
+                 name: str,
+                 params: RemoteServerParams,
+                 storage: TokenStorage | None = None):
+        self._name = name
+        self._params = params
+        self._session: ClientSession | None = None
+        self._exit_stack: AsyncExitStack | None = None
+        self._oauth_context: OAuthContext | None = self._init_oauth()
+        if self._params.oauth_params is not None and storage is not None:
+            self._params.oauth_params.oauth_token_storage = storage
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    def _init_http_headers(self) -> dict[str, str] | None:
+        if self._params.http_headers is None and self._params.bearer_token is None:
+            return None
+        headers = {}
+        if self._params.http_headers is not None:
+            headers.update(self._params.http_headers)
+        if self._params.bearer_token is not None:
+            headers["Authorization"] = f"Bearer {self._params.bearer_token}"
+        return headers
+
+    def _init_oauth(self) -> OAuthContext | None:
+        if self._params.oauth_params is None:
+            return None
+
+        oauth_params = self._params.oauth_params
+
+        server = LocalOAuthServer(timeout=oauth_params.oauth_timeout)
+        scopes = None
+        if oauth_params.oauth_scopes is not None:
+            scopes = " ".join(oauth_params.oauth_scopes)
+
+        client_provider = OAuthClientProvider(
+            server_url=self._params.url,
+            client_metadata=OAuthClientMetadata(
+                client_name=self._name,
+                redirect_uris=[AnyUrl(server.callback_url)],
+                grant_types=["authorization_code", "refresh_token"],
+                response_types=["code"],
+                scope=scopes,
+                token_endpoint_auth_method="none",
+            ),
+            storage=oauth_params.oauth_token_storage,
+            redirect_handler=self._handle_redirect,
+            callback_handler=self._handle_oauth_callback,
+        )
+        client = httpx.AsyncClient(auth=client_provider,
+                                   headers=self._init_http_headers(),
+                                   follow_redirects=True)
+        return OAuthContext(client, server)
+
+    async def _handle_redirect(self, url: str) -> None:
+        logger.info("[OAuth] Authentication required, opening browser...")
+        logger.info(f"[OAuth] If browser does not open automatically, copy and open the following link: \n{url}\n")
+        try:
+            webbrowser.open(url)
+        except Exception as e:
+            logger.error(f"[OAuth] Not able to open browser: {e}")
+
+    async def _handle_oauth_callback(self) -> OAuthCode:
+        if self._oauth_context is None:
+            raise ValueError("OAuth context not initialized")
+        return await self._oauth_context.server.wait_for_code()
+
+    async def connect(self):
+        self._exit_stack = AsyncExitStack()
+        if self._oauth_context:
+            http_client = self._oauth_context.client
+            await self._oauth_context.server.start()
+        else:
+            http_client = await self._exit_stack.enter_async_context(
+                httpx.AsyncClient(headers=self._init_http_headers(), follow_redirects=True))
+
+        try:
+            read_stream, write_stream, _ = await self._exit_stack.enter_async_context(
+                streamable_http_client(self._params.url, http_client=http_client)
+            )
+            self._session = await self._exit_stack.enter_async_context(
+                ClientSession(read_stream, write_stream)
+            )
+            await self._session.initialize()
+        except Exception:
+            await self.disconnect()
+            raise
+
+    async def list_tools(self) -> list[Tool]:
+        if not self._session:
+            raise McpSessionNotEstablishedError()
+
+        result = await self._session.list_tools()
+        return result.tools
+
+    async def call_tool(
+        self, tool_name: str, arguments: dict[str, Any] | None = None
+    ) -> ToolResult:
+        if not self._session:
+            raise McpSessionNotEstablishedError()
+
+        response = await self._session.call_tool(tool_name, arguments)
+        return ToolResult(response.isError, response.content)
+
+    async def disconnect(self):
+        try:
+            if self._exit_stack:
+                await self._exit_stack.aclose()
+        finally:
+            self._session = None
+            self._exit_stack = None
+
+            if self._oauth_context:
+                try: await self._oauth_context.client.aclose()
+                except Exception: pass
+                try: await self._oauth_context.server.stop()
+                except Exception: pass

dais_sdk/param_parser.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+from typing import Any, TYPE_CHECKING
+from litellm.types.utils import LlmProviders
+from .tool.prepare import prepare_tools
+from .types.message import ToolMessage
+
+if TYPE_CHECKING:
+    from .types.request_params import LlmRequestParams
+
+ParsedParams = dict[str, Any]
+
+class ParamParser:
+    def __init__(self,
+                 provider: LlmProviders,
+                 base_url: str,
+                 api_key: str):
+        self._provider = provider
+        self._base_url = base_url
+        self._api_key = api_key
+
+    def _parse(self, params: LlmRequestParams) -> ParsedParams:
+        extracted_tool_likes = params.extract_tools()
+        tools = extracted_tool_likes and prepare_tools(extracted_tool_likes)
+
+        transformed_messages = []
+        for message in params.messages:
+            if (type(message) is ToolMessage and
+                message.result is None and
+                message.error is None):
+                # skip ToolMessage that is not resolved
+                continue
+            transformed_messages.append(message.to_litellm_message())
+
+        return {
+            "model": f"{self._provider.value}/{params.model}",
+            "messages": transformed_messages,
+            "base_url": self._base_url,
+            "api_key": self._api_key,
+            "tools": tools,
+            "tool_choice": params.tool_choice,
+            "timeout": params.timeout_sec,
+            "extra_headers": params.headers,
+            **(params.extra_args or {})
+        }
+
+    def parse_nonstream(self, params: LlmRequestParams) -> ParsedParams:
+        parsed = self._parse(params)
+        parsed["stream"] = False
+        return parsed
+
+    def parse_stream(self, params: LlmRequestParams) -> ParsedParams:
+        parsed = self._parse(params)
+        parsed["stream"] = True
+        parsed["stream_options"] = {"include_usage": True}
+        return parsed

dais_sdk/stream.py

@@ -0,0 +1,82 @@
+import dataclasses
+from litellm import ChatCompletionAssistantToolCall
+from litellm.types.utils import (ChatCompletionDeltaToolCall,
+                                 ModelResponseStream as LiteLlmModelResponseStream)
+from .types.message import AssistantMessage
+
+@dataclasses.dataclass
+class ToolCallTemp:
+    id: str | None = None
+    name: str = ""
+    arguments: str = ""
+
+class ToolCallCollector:
+    def __init__(self):
+        self.tool_call_map: dict[int, ToolCallTemp] = {}
+
+    def collect(self, tool_call_chunk: ChatCompletionDeltaToolCall):
+        if tool_call_chunk.index not in self.tool_call_map:
+            self.tool_call_map[tool_call_chunk.index] = ToolCallTemp()
+
+        temp_tool_call = self.tool_call_map[tool_call_chunk.index]
+        if tool_call_chunk.get("id"):
+            temp_tool_call.id = tool_call_chunk.id
+        if tool_call_chunk.function.get("name"):
+            assert tool_call_chunk.function.name is not None
+            temp_tool_call.name += tool_call_chunk.function.name
+        if tool_call_chunk.function.get("arguments"):
+            assert tool_call_chunk.function.arguments is not None
+            temp_tool_call.arguments += tool_call_chunk.function.arguments
+
+    def get_tool_calls(self) -> list[ChatCompletionAssistantToolCall]:
+        return [{
+            "id": tool_call.id,
+            "function": {
+                "name": tool_call.name,
+                "arguments": tool_call.arguments,
+            },
+            "type": "function"
+        } for tool_call in self.tool_call_map.values()]
+
+class AssistantMessageCollector:
+    def __init__(self):
+        self.message_buf = AssistantMessage(content=None)
+        self.tool_call_collector = ToolCallCollector()
+
+    def collect(self, chunk: LiteLlmModelResponseStream):
+        delta = chunk.choices[0].delta
+        if delta.get("content"):
+            assert delta.content is not None
+            if self.message_buf.content is None:
+                self.message_buf.content = ""
+            self.message_buf.content += delta.content
+
+        if delta.get("reasoning_content"):
+            assert delta.reasoning_content is not None
+            if self.message_buf.reasoning_content is None:
+                self.message_buf.reasoning_content = ""
+            self.message_buf.reasoning_content += delta.reasoning_content
+
+        if delta.get("tool_calls"):
+            assert delta.tool_calls is not None
+            for tool_call_chunk in delta.tool_calls:
+                self.tool_call_collector.collect(tool_call_chunk)
+
+        if delta.get("images"):
+            assert delta.images is not None
+            if self.message_buf.images is None:
+                self.message_buf.images = []
+            self.message_buf.images = delta.images
+
+        if delta.get("audio"):
+            assert delta.audio is not None
+            self.message_buf.audio = delta.audio
+
+    def get_message(self) -> AssistantMessage:
+        self.message_buf.tool_calls = self.tool_call_collector.get_tool_calls()
+        return self.message_buf
+
+    def clear(self):
+        """
+        This class will be created for each stream, so we don't need to clear it.
+        """

dais_sdk/tool/execute.py

@@ -0,0 +1,65 @@
+import asyncio
+import json
+from functools import singledispatch
+from typing import Any, Awaitable, Callable, cast
+from types import FunctionType, MethodType, CoroutineType
+from ..types.tool import ToolDef, ToolLike
+
+async def _coroutine_wrapper(awaitable: Awaitable[Any]) -> CoroutineType:
+    return await awaitable
+
+def _arguments_normalizer(arguments: str | dict) -> dict:
+    if isinstance(arguments, str):
+        parsed = json.loads(arguments)
+        return cast(dict, parsed)
+    elif isinstance(arguments, dict):
+        return arguments
+    else:
+        raise ValueError(f"Invalid arguments type: {type(arguments)}")
+
+def _result_normalizer(result: Any) -> str:
+    if isinstance(result, str):
+        return result
+    return json.dumps(result, ensure_ascii=False)
+
+@singledispatch
+def execute_tool_sync(tool: ToolLike, arguments: str | dict) -> str:
+    raise ValueError(f"Invalid tool type: {type(tool)}")
+
+@execute_tool_sync.register(FunctionType)
+@execute_tool_sync.register(MethodType)
+def _(toolfn: Callable, arguments: str | dict) -> str:
+    arguments = _arguments_normalizer(arguments)
+    result = (asyncio.run(_coroutine_wrapper(toolfn(**arguments)))
+              if asyncio.iscoroutinefunction(toolfn)
+              else toolfn(**arguments))
+    return _result_normalizer(result)
+
+@execute_tool_sync.register(ToolDef)
+def _(tooldef: ToolDef, arguments: str | dict) -> str:
+    arguments = _arguments_normalizer(arguments)
+    result = (asyncio.run(_coroutine_wrapper(tooldef.execute(**arguments)))
+              if asyncio.iscoroutinefunction(tooldef.execute)
+              else tooldef.execute(**arguments))
+    return _result_normalizer(result)
+
+@singledispatch
+async def execute_tool(tool: ToolLike, arguments: str | dict) -> str:
+    raise ValueError(f"Invalid tool type: {type(tool)}")
+
+@execute_tool.register(FunctionType)
+@execute_tool.register(MethodType)
+async def _(toolfn: Callable, arguments: str | dict) -> str:
+    arguments = _arguments_normalizer(arguments)
+    result = (await toolfn(**arguments)
+             if asyncio.iscoroutinefunction(toolfn)
+             else toolfn(**arguments))
+    return _result_normalizer(result)
+
+@execute_tool.register(ToolDef)
+async def _(tooldef: ToolDef, arguments: str | dict) -> str:
+    arguments = _arguments_normalizer(arguments)
+    result = (await tooldef.execute(**arguments)
+             if asyncio.iscoroutinefunction(tooldef.execute)
+             else tooldef.execute(**arguments))
+    return _result_normalizer(result)

dais_sdk/tool/prepare.py

@@ -0,0 +1,283 @@
+"""
+source: https://github.com/mozilla-ai/any-llm/blob/main/src/any_llm/tools.py
+"""
+
+import dataclasses
+import enum
+import inspect
+import types as _types
+from collections.abc import Mapping, Sequence
+from datetime import date, datetime, time
+from typing import (Annotated as _Annotated, Literal as _Literal,
+                    is_typeddict as _is_typeddict, Any, get_args,
+                    get_origin, get_type_hints)
+from pydantic import BaseModel as PydanticBaseModel
+from ..types.tool import ToolFn, ToolDef, RawToolDef, ToolLike
+
+def _python_type_to_json_schema(python_type: Any) -> dict[str, Any]:
+    """Convert Python type annotation to a JSON Schema for a parameter.
+
+    Supported mappings (subset tailored for LLM tool schemas):
+    - Primitives: str/int/float/bool -> string/integer/number/boolean
+    - bytes -> string with contentEncoding base64
+    - datetime/date/time -> string with format date-time/date/time
+    - list[T] / Sequence[T] / set[T] / frozenset[T] -> array with items=schema(T)
+      - set/frozenset include uniqueItems=true
+      - list without type args defaults items to string
+    - dict[K,V] / Mapping[K,V] -> object with additionalProperties=schema(V)
+      - dict without type args defaults additionalProperties to string
+    - tuple[T1, T2, ...] -> array with prefixItems per element and min/maxItems
+    - tuple[T, ...] -> array with items=schema(T)
+    - Union[X, Y] and X | Y -> oneOf=[schema(X), schema(Y)] (without top-level type)
+    - Optional[T] (Union[T, None]) -> schema(T) (nullability not encoded)
+    - Literal[...]/Enum -> enum with appropriate type inference when uniform
+    - TypedDict -> object with properties/required per annotations
+    - dataclass/Pydantic BaseModel -> object with nested properties inferred from fields
+    """
+    origin = get_origin(python_type)
+    args = get_args(python_type)
+
+    if _Annotated is not None and origin is _Annotated and len(args) >= 1:
+        python_type = args[0]
+        origin = get_origin(python_type)
+        args = get_args(python_type)
+
+    if python_type is Any:
+        return {"type": "string"}
+
+    primitive_map = {str: "string", int: "integer", float: "number", bool: "boolean"}
+    if python_type in primitive_map:
+        return {"type": primitive_map[python_type]}
+
+    if python_type is bytes:
+        return {"type": "string", "contentEncoding": "base64"}
+    if python_type is datetime:
+        return {"type": "string", "format": "date-time"}
+    if python_type is date:
+        return {"type": "string", "format": "date"}
+    if python_type is time:
+        return {"type": "string", "format": "time"}
+
+    if python_type is list:
+        return {"type": "array", "items": {"type": "string"}}
+    if python_type is dict:
+        return {"type": "object", "additionalProperties": {"type": "string"}}
+
+    if origin is _Literal:
+        literal_values = list(args)
+        schema_lit: dict[str, Any] = {"enum": literal_values}
+        if all(isinstance(v, bool) for v in literal_values):
+            schema_lit["type"] = "boolean"
+        elif all(isinstance(v, str) for v in literal_values):
+            schema_lit["type"] = "string"
+        elif all(isinstance(v, int) and not isinstance(v, bool) for v in literal_values):
+            schema_lit["type"] = "integer"
+        elif all(isinstance(v, int | float) and not isinstance(v, bool) for v in literal_values):
+            schema_lit["type"] = "number"
+        return schema_lit
+
+    if inspect.isclass(python_type) and issubclass(python_type, enum.Enum):
+        enum_values = [e.value for e in python_type]
+        value_types = {type(v) for v in enum_values}
+        schema: dict[str, Any] = {"enum": enum_values}
+        if value_types == {str}:
+            schema["type"] = "string"
+        elif value_types == {int}:
+            schema["type"] = "integer"
+        elif value_types <= {int, float}:
+            schema["type"] = "number"
+        elif value_types == {bool}:
+            schema["type"] = "boolean"
+        return schema
+
+    if _is_typeddict(python_type):
+        annotations: dict[str, Any] = getattr(python_type, "__annotations__", {}) or {}
+        required_keys = set(getattr(python_type, "__required_keys__", set()))
+        td_properties: dict[str, Any] = {}
+        td_required: list[str] = []
+        for field_name, field_type in annotations.items():
+            td_properties[field_name] = _python_type_to_json_schema(field_type)
+            if field_name in required_keys:
+                td_required.append(field_name)
+        schema_td: dict[str, Any] = {
+            "type": "object",
+            "properties": td_properties,
+        }
+        if td_required:
+            schema_td["required"] = td_required
+        return schema_td
+
+    if inspect.isclass(python_type) and dataclasses.is_dataclass(python_type):
+        type_hints = get_type_hints(python_type)
+        dc_properties: dict[str, Any] = {}
+        dc_required: list[str] = []
+        for field in dataclasses.fields(python_type):
+            field_type = type_hints.get(field.name, Any)
+            dc_properties[field.name] = _python_type_to_json_schema(field_type)
+            if (
+                field.default is dataclasses.MISSING
+                and getattr(field, "default_factory", dataclasses.MISSING) is dataclasses.MISSING
+            ):
+                dc_required.append(field.name)
+        schema_dc: dict[str, Any] = {"type": "object", "properties": dc_properties}
+        if dc_required:
+            schema_dc["required"] = dc_required
+        return schema_dc
+
+    if inspect.isclass(python_type) and issubclass(python_type, PydanticBaseModel):
+        model_type_hints = get_type_hints(python_type)
+        pd_properties: dict[str, Any] = {}
+        pd_required: list[str] = []
+        model_fields = getattr(python_type, "model_fields", {})
+        for name, field_info in model_fields.items():
+            pd_properties[name] = _python_type_to_json_schema(model_type_hints.get(name, Any))
+            is_required = getattr(field_info, "is_required", None)
+            if callable(is_required) and is_required():
+                pd_required.append(name)
+        schema_pd: dict[str, Any] = {"type": "object", "properties": pd_properties}
+        if pd_required:
+            schema_pd["required"] = pd_required
+        return schema_pd
+
+    if origin in (list, Sequence, set, frozenset):
+        item_type = args[0] if args else Any
+        item_schema = _python_type_to_json_schema(item_type)
+        schema_arr: dict[str, Any] = {"type": "array", "items": item_schema or {"type": "string"}}
+        if origin in (set, frozenset):
+            schema_arr["uniqueItems"] = True
+        return schema_arr
+    if origin is tuple:
+        if not args:
+            return {"type": "array", "items": {"type": "string"}}
+        if len(args) == 2 and args[1] is Ellipsis:
+            return {"type": "array", "items": _python_type_to_json_schema(args[0])}
+        prefix_items = [_python_type_to_json_schema(a) for a in args]
+        return {
+            "type": "array",
+            "prefixItems": prefix_items,
+            "minItems": len(prefix_items),
+            "maxItems": len(prefix_items),
+        }
+
+    if origin in (dict, Mapping):
+        value_type = args[1] if len(args) >= 2 else Any
+        value_schema = _python_type_to_json_schema(value_type)
+        return {"type": "object", "additionalProperties": value_schema or {"type": "string"}}
+
+    typing_union = getattr(__import__("typing"), "Union", None)
+    if origin in (typing_union, _types.UnionType):
+        non_none_args = [a for a in args if a is not type(None)]
+        if len(non_none_args) > 1:
+            schemas = [_python_type_to_json_schema(arg) for arg in non_none_args]
+            return {"oneOf": schemas}
+        if non_none_args:
+            return _python_type_to_json_schema(non_none_args[0])
+        return {"type": "string"}
+
+    return {"type": "string"}
+
+def _parse_callable_properties(func: ToolFn) -> tuple[dict[str, dict[str, Any]], list[str]]:
+    sig = inspect.signature(func)
+    type_hints = get_type_hints(func)
+
+    properties: dict[str, dict[str, Any]] = {}
+    required: list[str] = []
+
+    for param_name, param in sig.parameters.items():
+        if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+            continue
+
+        annotated_type = type_hints.get(param_name, str)
+        param_schema = _python_type_to_json_schema(annotated_type)
+
+        type_name = getattr(annotated_type, "__name__", str(annotated_type))
+        properties[param_name] = {
+            **param_schema,
+            "description": f"Parameter {param_name} of type {type_name}",
+        }
+
+        if param.default == inspect.Parameter.empty:
+            required.append(param_name)
+
+    return properties, required
+
+def generate_tool_definition_from_callable(func: ToolFn) -> dict[str, Any]:
+    """Convert a Python callable to OpenAI tools format.
+
+    Args:
+        func: A Python callable (function) to convert to a tool
+
+    Returns:
+        Dictionary in OpenAI tools format
+
+    Raises:
+        ValueError: If the function doesn't have proper docstring or type annotations
+
+    Example:
+        >>> def get_weather(location: str, unit: str = "celsius") -> str:
+        ...     '''Get weather information for a location.'''
+        ...     return f"Weather in {location} is sunny, 25°{unit[0].upper()}"
+        >>>
+        >>> tool = generate_tool_definition_from_callable(get_weather)
+        >>> # Returns OpenAI tools format dict
+
+    """
+    if not func.__doc__:
+        msg = f"Function {func.__name__} must have a docstring"
+        raise ValueError(msg)
+
+    properties, required = _parse_callable_properties(func)
+    return {
+        "type": "function",
+        "function": {
+            "name": func.__name__,
+            "description": inspect.cleandoc(func.__doc__),
+            "parameters": {"type": "object", "properties": properties, "required": required},
+        },
+    }
+
+def generate_tool_definition_from_tool_def(tool_def: ToolDef) -> dict[str, Any]:
+    """Convert a ToolDef to OpenAI tools format.
+
+    Args:
+        tool_def: A ToolDef to convert to a tool
+
+    Returns:
+        Dictionary in OpenAI tools format
+
+    Example:
+        >>> tool_def = ToolDef(
+        ...     name="get_weather",
+        ...     description="Get weather information for a location.",
+        ...     execute=SomeFunction(),
+        ... )
+        >>> tool = generate_tool_definition_from_tool_def(tool_def)
+        >>> # Returns OpenAI tools format dict
+    """
+    properties, required = _parse_callable_properties(tool_def.execute)
+    return {
+        "type": "function",
+        "function": {
+            "name": tool_def.name,
+            "description": tool_def.description,
+            "parameters": (tool_def.parameters or
+                          {"type": "object", "properties": properties, "required": required}),
+        },
+    }
+
+def generate_tool_definition_from_raw_tool_def(raw_tool_def: RawToolDef) -> dict[str, Any]:
+    return {
+        "type": "function",
+        "function": raw_tool_def,
+    }
+
+def prepare_tools(tools: Sequence[ToolLike]) -> list[dict]:
+    tool_defs = []
+    for tool in tools:
+        if callable(tool):
+            tool_defs.append(generate_tool_definition_from_callable(tool))
+        elif isinstance(tool, ToolDef):
+            tool_defs.append(generate_tool_definition_from_tool_def(tool))
+        else:
+            tool_defs.append(generate_tool_definition_from_raw_tool_def(tool))
+    return tool_defs

dais_sdk/tool/toolset/__init__.py

@@ -0,0 +1,18 @@
+from .toolset import Toolset
+from .python_toolset import PythonToolset, python_tool
+from .mcp_toolset import (
+    McpToolset,
+    LocalMcpToolset,
+    RemoteMcpToolset,
+)
+
+__all__ = [
+    "Toolset",
+
+    "PythonToolset",
+    "python_tool",
+
+    "McpToolset",
+    "LocalMcpToolset",
+    "RemoteMcpToolset",
+]