glaip-sdk 0.6.15b2__py3-none-any.whl → 0.6.15b3__py3-none-any.whl

glaip_sdk/runner/mcp_adapter/__init__.py

@@ -0,0 +1,13 @@
+"""MCP adapter module for local agent runtime.
+
+This module provides MCP adapters for converting glaip-sdk MCP references
+to backend-specific MCP configuration formats.
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+from glaip_sdk.runner.mcp_adapter.base_mcp_adapter import BaseMCPAdapter
+from glaip_sdk.runner.mcp_adapter.langchain_mcp_adapter import LangChainMCPAdapter
+
+__all__ = ["BaseMCPAdapter", "LangChainMCPAdapter"]

glaip_sdk/runner/mcp_adapter/base_mcp_adapter.py

@@ -0,0 +1,43 @@
+"""Base MCP adapter for local agent runtime.
+
+This module defines the abstract base class for MCP adapters.
+Different backends (LangGraph, Google ADK) implement their own adapters.
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class BaseMCPAdapter(ABC):
+    """Abstract base class for MCP adapters.
+
+    One Interface, Multiple Implementations:
+    - LangChainMCPAdapter: Adapts to aip-agents mcp_config format
+    - GoogleADKMCPAdapter: Adapts to Google ADK format (future)
+
+    Each backend implements this interface to adapt glaip-sdk MCPs
+    to their specific MCP configuration format.
+    """
+
+    @abstractmethod
+    def adapt_mcps(self, mcp_refs: list[Any]) -> dict[str, Any]:
+        """Adapt glaip-sdk MCP references to backend-specific format.
+
+        Args:
+            mcp_refs: List of MCP references from Agent definition.
+                Can be: MCP class instances, MCP.from_native() refs, etc.
+
+        Returns:
+            Backend-specific MCP configuration.
+            For LangChain/aip-agents: dict[str, dict[str, Any]] mapping server names to config.
+            For Google ADK: dict in Google ADK MCP format.
+
+        Raises:
+            ValueError: If MCP is not supported by this backend.
+        """
+        ...

glaip_sdk/runner/mcp_adapter/langchain_mcp_adapter.py

@@ -0,0 +1,257 @@
+"""LangChain MCP adapter for local agent runtime.
+
+This module handles adaptation of glaip-sdk MCP references to aip-agents
+MCP configuration format for local execution.
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+from typing import Any
+
+from glaip_sdk.runner.mcp_adapter.base_mcp_adapter import BaseMCPAdapter
+from glaip_sdk.runner.mcp_adapter.mcp_config_builder import MCPConfigBuilder
+from gllm_core.utils import LoggerManager
+
+logger = LoggerManager().get_logger(__name__)
+
+
+class LangChainMCPAdapter(BaseMCPAdapter):
+    """Adapts glaip-sdk MCPs to aip-agents mcp_config dict format.
+
+    Handles:
+    - MCP class with http transport → convert to mcp_config
+    - MCP class with sse transport → convert to mcp_config
+    - MCP class with stdio transport → convert to mcp_config
+
+    Rejects:
+    - MCP.from_native() → platform-specific
+    - String MCP references → platform-specific
+    """
+
+    def adapt_mcps(self, mcp_refs: list[Any]) -> dict[str, Any]:
+        """Adapt MCP references to aip-agents mcp_config format.
+
+        Args:
+            mcp_refs: List of MCP references from Agent definition.
+
+        Returns:
+            Dictionary mapping server names to configuration dicts.
+            Format: {server_name: {transport: ..., url: ..., ...}}
+
+        Raises:
+            ValueError: If MCP is not supported in local mode.
+        """
+        mcp_configs = {}
+
+        for mcp_ref in mcp_refs:
+            server_name, config = self._adapt_single_mcp(mcp_ref)
+            mcp_configs[server_name] = config
+
+        logger.debug("Adapted %d MCPs to aip-agents format", len(mcp_configs))
+        return mcp_configs
+
+    def _adapt_single_mcp(self, mcp_ref: Any) -> tuple[str, dict[str, Any]]:
+        """Adapt a single MCP reference.
+
+        Args:
+            mcp_ref: Single MCP reference to adapt.
+
+        Returns:
+            Tuple of (server_name, config_dict).
+
+        Raises:
+            ValueError: If MCP is not supported.
+        """
+        # 1. String references (not supported)
+        if isinstance(mcp_ref, str):
+            raise ValueError(self._get_platform_mcp_error(mcp_ref))
+
+        # 2. MCP instance - check if it's local or platform
+        if self._is_local_mcp(mcp_ref):
+            config = self._convert_mcp_config(mcp_ref)
+            return mcp_ref.name, config
+
+        # 3. Platform MCP (from_native, from_id)
+        if self._is_platform_mcp(mcp_ref):
+            raise ValueError(self._get_platform_mcp_error(mcp_ref))
+
+        # 4. Unknown type
+        raise ValueError(
+            f"Unsupported MCP type for local mode: {type(mcp_ref)}. "
+            "Local mode only supports MCP class instances with http/sse/stdio transport."
+        )
+
+    def _is_local_mcp(self, ref: Any) -> bool:
+        """Check if ref is a local MCP (has transport config)."""
+        return (
+            hasattr(ref, "transport")
+            and hasattr(ref, "name")
+            and getattr(ref, "transport", None) in ("http", "sse", "stdio")
+            and not self._is_lookup_only(ref)
+        )
+
+    def _is_lookup_only(self, ref: Any) -> bool:
+        """Check if MCP is lookup-only (platform reference)."""
+        return hasattr(ref, "_lookup_only") and getattr(ref, "_lookup_only", False)
+
+    def _convert_mcp_config(self, mcp: Any) -> dict[str, Any]:
+        """Convert glaip-sdk MCP to aip-agents mcp_config format.
+
+        Args:
+            mcp: glaip-sdk MCP instance.
+
+        Returns:
+            aip-agents compatible MCP config dict.
+        """
+        # Start with user-provided config
+        config = mcp.config.copy() if mcp.config else {}
+
+        # Ensure transport is set
+        config["transport"] = mcp.transport
+
+        # Map server_url to url if needed (aip-agents uses 'url')
+        if "server_url" in config and "url" not in config:
+            config["url"] = config.pop("server_url")
+
+        self._validate_converted_config(
+            mcp_name=mcp.name,
+            transport=mcp.transport,
+            config=config,
+        )
+
+        # Convert authentication to headers using MCPConfigBuilder
+        # Merge with existing headers (auth headers take precedence for conflicts)
+        if hasattr(mcp, "authentication") and mcp.authentication:
+            auth_headers = MCPConfigBuilder.build_headers_from_auth(mcp.authentication)
+            if auth_headers:
+                existing_headers = config.get("headers", {})
+                config["headers"] = {**existing_headers, **auth_headers}
+            else:
+                logger.warning("Failed to build headers from authentication for MCP '%s'", mcp.name)
+
+        logger.debug("Converted MCP '%s' with transport '%s'", mcp.name, mcp.transport)
+        return config
+
+    def _validate_converted_config(self, mcp_name: str, transport: str, config: dict[str, Any]) -> None:
+        """Validate converted MCP config matches aip-agents schema expectations.
+
+        This method performs transport-specific validation after the glaip-sdk MCP
+        has been converted into the `aip-agents` `mcp_config` dictionary.
+
+        Args:
+            mcp_name: The MCP server name.
+            transport: The MCP transport type.
+            config: The converted MCP configuration dictionary.
+
+        Raises:
+            ValueError: If the configuration is invalid for the chosen transport.
+        """
+        self._validate_transport_config(mcp_name, transport)
+        if transport in ("http", "sse"):
+            self._validate_http_sse_config(
+                mcp_name=mcp_name,
+                transport=transport,
+                config=config,
+            )
+            return
+        if transport == "stdio":
+            self._validate_stdio_config(
+                mcp_name=mcp_name,
+                config=config,
+            )
+
+    def _validate_transport_config(self, mcp_name: str, transport: str) -> None:
+        """Validate that the MCP transport is supported by local mode.
+
+        Args:
+            mcp_name: The MCP server name.
+            transport: The MCP transport type.
+
+        Raises:
+            ValueError: If the transport is not one of 'http', 'sse', or 'stdio'.
+        """
+        if transport not in ("http", "sse", "stdio"):
+            raise ValueError(
+                f"Invalid MCP config for '{mcp_name}': transport must be one of "
+                f"'http', 'sse', or 'stdio'. Got: {transport!r}"
+            )
+
+    def _validate_http_sse_config(self, mcp_name: str, transport: str, config: dict[str, Any]) -> None:
+        """Validate http/sse config has a usable URL.
+
+        Args:
+            mcp_name: The MCP server name.
+            transport: The MCP transport type ('http' or 'sse').
+            config: The converted MCP configuration dictionary.
+
+        Raises:
+            ValueError: If url is missing/empty or does not use http(s) scheme.
+        """
+        url = config.get("url")
+        if not isinstance(url, str) or not url:
+            raise ValueError(
+                f"Invalid MCP config for '{mcp_name}': transport='{transport}' "
+                "requires config['url'] as a non-empty string."
+            )
+
+        if not (url.startswith("http://") or url.startswith("https://")):
+            raise ValueError(
+                f"Invalid MCP config for '{mcp_name}': config['url'] must start with "
+                f"'http://' or 'https://'. Got: {url!r}"
+            )
+
+    def _validate_stdio_config(self, mcp_name: str, config: dict[str, Any]) -> None:
+        """Validate stdio config has a usable command and optional args list.
+
+        Args:
+            mcp_name: The MCP server name.
+            config: The converted MCP configuration dictionary.
+
+        Raises:
+            ValueError: If command is missing/empty or args is not a list of strings.
+        """
+        command = config.get("command")
+        if not isinstance(command, str) or not command:
+            raise ValueError(
+                f"Invalid MCP config for '{mcp_name}': transport='stdio' "
+                "requires config['command'] as a non-empty string."
+            )
+
+        args = config.get("args")
+        if args is not None and (not isinstance(args, list) or any(not isinstance(x, str) for x in args)):
+            raise ValueError(
+                f"Invalid MCP config for '{mcp_name}': transport='stdio' expects "
+                "config['args'] to be a list[str] if provided."
+            )
+
+    def _is_platform_mcp(self, ref: Any) -> bool:
+        """Check if ref is platform-specific (not supported locally)."""
+        # MCP.from_native() or MCP.from_id() instances
+        if self._is_lookup_only(ref):
+            return True
+
+        # MCP with ID but no local transport
+        if hasattr(ref, "id") and getattr(ref, "id") and not self._is_local_mcp(ref):
+            return True
+
+        return False
+
+    def _get_platform_mcp_error(self, ref: Any) -> str:
+        """Get error message for platform MCPs."""
+        if isinstance(ref, str):
+            mcp_name = ref
+        else:
+            mcp_name = getattr(ref, "name", "<unknown>")
+
+        return (
+            f"MCP '{mcp_name}' is not supported in local mode.\n\n"
+            "Local mode only supports MCPs with local transport configurations:\n"
+            "  - MCP(name='...', transport='http', config={{'url': '...'}})\n"
+            "  - MCP(name='...', transport='sse', config={{'url': '...'}})\n"
+            "  - MCP(name='...', transport='stdio', config={{'command': '...'}})\n\n"
+            "Alternatives:\n"
+            "  1. Configure MCP with a local server URL\n"
+            "  2. Deploy the agent to use platform MCPs: agent.deploy()\n"
+            "  3. Remove MCP for local testing"
+        )

glaip_sdk/runner/mcp_adapter/mcp_config_builder.py

@@ -0,0 +1,95 @@
+"""MCP configuration builder helper.
+
+This module provides utilities for building MCP configurations,
+particularly for handling authentication conversion to headers.
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+from typing import Any
+
+from gllm_core.utils import LoggerManager
+
+logger = LoggerManager().get_logger(__name__)
+
+
+class MCPConfigBuilder:
+    """Helper class for building MCP configurations.
+
+    Handles authentication-to-headers conversion and configuration validation.
+    Simplified version focused on local MCP support needs.
+    """
+
+    @staticmethod
+    def build_headers_from_auth(authentication: dict[str, Any]) -> dict[str, str] | None:
+        """Build HTTP headers from authentication configuration.
+
+        Args:
+            authentication: Authentication configuration dict with 'type' and auth-specific fields.
+
+        Returns:
+            dict[str, str] | None: HTTP headers or None if invalid/no-auth.
+        """
+        if not authentication or "type" not in authentication:
+            return None
+
+        auth_type = str(authentication["type"]).lower()
+
+        # Dispatch to type-specific handlers
+        handlers = {
+            "no-auth": MCPConfigBuilder._handle_no_auth,
+            "custom-header": MCPConfigBuilder._handle_custom_header,
+            "bearer-token": MCPConfigBuilder._handle_bearer_token,
+            "api-key": MCPConfigBuilder._handle_api_key,
+        }
+
+        handler = handlers.get(auth_type)
+        if handler:
+            return handler(authentication)
+
+        logger.warning("Unsupported authentication type: %s", auth_type)
+        return None
+
+    @staticmethod
+    def _handle_no_auth(authentication: dict[str, Any]) -> None:  # noqa: ARG004
+        """Handle no-auth type."""
+        return None
+
+    @staticmethod
+    def _handle_custom_header(authentication: dict[str, Any]) -> dict[str, str] | None:
+        """Handle custom-header auth type."""
+        headers = authentication.get("headers")
+        if isinstance(headers, dict) and all(isinstance(k, str) and isinstance(v, str) for k, v in headers.items()):
+            return headers
+        logger.warning("custom-header auth requires 'headers' dict with string keys/values")
+        return None
+
+    @staticmethod
+    def _handle_bearer_token(authentication: dict[str, Any]) -> dict[str, str] | None:
+        """Handle bearer-token auth type."""
+        # Check if headers provided directly
+        headers = authentication.get("headers")
+        if isinstance(headers, dict):
+            return headers
+        # Otherwise build from token
+        token = authentication.get("token")
+        if token:
+            return {"Authorization": f"Bearer {token}"}
+        logger.warning("bearer-token auth requires 'token' field or 'headers' dict")
+        return None
+
+    @staticmethod
+    def _handle_api_key(authentication: dict[str, Any]) -> dict[str, str] | None:
+        """Handle api-key auth type."""
+        # Check if headers provided directly
+        headers = authentication.get("headers")
+        if isinstance(headers, dict):
+            return headers
+        # Otherwise build from key/value
+        key = authentication.get("key")
+        value = authentication.get("value")
+        if key and value:
+            return {str(key): str(value)}
+        logger.warning("api-key auth requires 'key' and 'value' fields or 'headers' dict")
+        return None

glaip_sdk/runner/tool_adapter/__init__.py

@@ -0,0 +1,18 @@
+"""Tool adapter for local agent runtime.
+
+This package provides adapters to convert glaip-sdk tool references
+to backend-specific formats for local execution.
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+from glaip_sdk.runner.tool_adapter.base_tool_adapter import BaseToolAdapter
+from glaip_sdk.runner.tool_adapter.langchain_tool_adapter import (
+    LangChainToolAdapter,
+)
+
+__all__ = [
+    "BaseToolAdapter",
+    "LangChainToolAdapter",
+]

glaip_sdk/runner/tool_adapter/base_tool_adapter.py

@@ -0,0 +1,44 @@
+"""Base tool adapter for local agent runtime.
+
+This module defines the abstract base class for tool adapters.
+Different backends (LangGraph, Google ADK) implement their own adapters.
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class BaseToolAdapter(ABC):
+    """Abstract base class for tool adapters.
+
+    One Interface, Multiple Implementations:
+    - LangChainToolAdapter: Adapts to LangChain BaseTool (for aip-agents)
+    - GoogleADKToolAdapter: Adapts to Google ADK format (future)
+
+    Each backend implements this interface to adapt glaip-sdk tools
+    to their specific tool format.
+    """
+
+    @abstractmethod
+    def adapt_tools(self, tool_refs: list[Any]) -> list[Any]:
+        """Adapt glaip-sdk tool references to backend-specific format.
+
+        Args:
+            tool_refs: List of tool references from Agent definition.
+                Can be: LangChain classes/instances, Tool.from_langchain(),
+                Tool.from_native(), string names, etc.
+
+        Returns:
+            List of tools in backend-specific format.
+            For LangChain: list of BaseTool instances.
+            For Google ADK: list of Google ADK tool objects.
+
+        Raises:
+            ValueError: If tool is not supported by this backend.
+        """
+        ...

glaip_sdk/runner/tool_adapter/langchain_tool_adapter.py

@@ -0,0 +1,219 @@
+"""LangChain tool adapter for local agent runtime.
+
+This module handles adaptation of glaip-sdk tool references to LangChain
+BaseTool instances for local execution with aip-agents (LangGraph backend).
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+from typing import Any
+
+from glaip_sdk.runner.tool_adapter.base_tool_adapter import BaseToolAdapter
+from gllm_core.utils import LoggerManager
+
+logger = LoggerManager().get_logger(__name__)
+
+# Constant for unknown tool name placeholder
+_UNKNOWN_TOOL_NAME = "<unknown>"
+
+
+class LangChainToolAdapter(BaseToolAdapter):
+    """Adapts glaip-sdk tools to LangChain BaseTool format for aip-agents.
+
+    Handles:
+    - LangChain BaseTool classes → instantiate
+    - LangChain BaseTool instances → return as-is
+    - Tool.from_langchain() → extract underlying tool
+    - @tool_plugin decorator → ignore (just metadata)
+
+    Rejects:
+    - Tool.from_native() → platform-specific
+    - String tool names → platform-specific
+    """
+
+    def adapt_tools(self, tool_refs: list[Any]) -> list[Any]:
+        """Adapt tool references to LangChain BaseTool instances.
+
+        Args:
+            tool_refs: List of tool references from Agent definition.
+
+        Returns:
+            List of LangChain BaseTool instances.
+
+        Raises:
+            ValueError: If tool is not supported in local mode.
+        """
+        langchain_tools = []
+
+        for tool_ref in tool_refs:
+            langchain_tool = self._adapt_single_tool(tool_ref)
+            langchain_tools.append(langchain_tool)
+
+        logger.debug("Adapted %d tools to LangChain format", len(langchain_tools))
+        return langchain_tools
+
+    def _adapt_single_tool(self, tool_ref: Any) -> Any:
+        """Adapt a single tool reference.
+
+        Args:
+            tool_ref: Single tool reference to adapt.
+
+        Returns:
+            LangChain BaseTool instance.
+
+        Raises:
+            ValueError: If tool is not supported.
+        """
+        # 1. Tool.from_langchain() wrapper
+        if self._is_tool_wrapper(tool_ref):
+            return self._extract_from_wrapper(tool_ref)
+
+        # 2. Direct LangChain BaseTool
+        if self._is_langchain_tool(tool_ref):
+            return self._instantiate_langchain_tool(tool_ref)
+
+        # 3. Platform tools (not supported)
+        if self._is_platform_tool(tool_ref):
+            raise ValueError(self._get_platform_tool_error(tool_ref))
+
+        # 4. Unknown type
+        raise ValueError(
+            f"Unsupported tool type for local mode: {type(tool_ref)}. "
+            "Local mode only supports LangChain BaseTool classes/instances."
+        )
+
+    def _has_explicit_attr(self, ref: Any, attr: str) -> bool:
+        """Check if attribute is explicitly set on the object.
+
+        This avoids false positives from objects like MagicMock, where hasattr()
+        can return True even if the attribute was never set.
+        """
+        ref_dict = getattr(ref, "__dict__", None)
+        return isinstance(ref_dict, dict) and attr in ref_dict
+
+    def _is_tool_wrapper(self, ref: Any) -> bool:
+        """Check if ref is a Tool.from_langchain() wrapper.
+
+        Args:
+            ref: Object to check.
+
+        Returns:
+            True if ref is a Tool.from_langchain() wrapper.
+        """
+        if self._has_explicit_attr(ref, "langchain_tool") and hasattr(ref, "id") and hasattr(ref, "name"):
+            return True
+
+        if self._has_explicit_attr(ref, "tool_class"):
+            return getattr(ref, "tool_class", None) is not None
+
+        return False
+
+    def _extract_from_wrapper(self, wrapper: Any) -> Any:
+        """Extract underlying LangChain tool from Tool.from_langchain().
+
+        Args:
+            wrapper: Tool.from_langchain() wrapper object.
+
+        Returns:
+            LangChain BaseTool instance.
+
+        Raises:
+            ValueError: If the wrapper's underlying tool is not a valid LangChain tool.
+        """
+        langchain_tool = getattr(wrapper, "langchain_tool", None)
+        if langchain_tool is None:
+            langchain_tool = getattr(wrapper, "tool_class", None)
+
+        # Validate the extracted object is a valid LangChain tool
+        if langchain_tool is None:
+            wrapper_name = getattr(wrapper, "name", _UNKNOWN_TOOL_NAME)
+            raise ValueError(
+                f"Tool wrapper '{wrapper_name}' does not contain a valid LangChain tool. "
+                "Ensure Tool.from_langchain() was called with a LangChain BaseTool class or instance."
+            )
+
+        # Validate it's actually a LangChain tool (class or instance)
+        if not self._is_langchain_tool(langchain_tool):
+            wrapper_name = getattr(wrapper, "name", _UNKNOWN_TOOL_NAME)
+            raise ValueError(
+                f"Tool wrapper '{wrapper_name}' contains an invalid tool type: {type(langchain_tool)}. "
+                "Expected a LangChain BaseTool class or instance."
+            )
+
+        # If it's a class, instantiate it
+        if isinstance(langchain_tool, type):
+            langchain_tool = langchain_tool()
+
+        logger.debug(
+            "Extracted LangChain tool from wrapper: %s",
+            getattr(langchain_tool, "name", _UNKNOWN_TOOL_NAME),
+        )
+        return langchain_tool
+
+    def _is_langchain_tool(self, ref: Any) -> bool:
+        """Check if ref is a LangChain BaseTool class or instance.
+
+        Args:
+            ref: Object to check.
+
+        Returns:
+            True if ref is a LangChain BaseTool.
+        """
+        from glaip_sdk.utils.tool_detection import is_langchain_tool  # noqa: PLC0415
+
+        return is_langchain_tool(ref)
+
+    def _instantiate_langchain_tool(self, ref: Any) -> Any:
+        """Instantiate LangChain tool if class, return as-is if instance.
+
+        Args:
+            ref: LangChain BaseTool class or instance.
+
+        Returns:
+            LangChain BaseTool instance.
+        """
+        if isinstance(ref, type):
+            # It's a class, instantiate it
+            # Note: @tool_plugin decorator doesn't affect instantiation
+            return ref()
+        return ref
+
+    def _is_platform_tool(self, ref: Any) -> bool:
+        """Check if ref is platform-specific (not supported locally).
+
+        Args:
+            ref: Object to check.
+
+        Returns:
+            True if ref is a platform-specific tool.
+        """
+        # String tool names
+        if isinstance(ref, str):
+            return True
+
+        # Tool.from_native() instances
+        if hasattr(ref, "id") and hasattr(ref, "name") and not self._has_explicit_attr(ref, "langchain_tool"):
+            tool_class = getattr(ref, "tool_class", None) if self._has_explicit_attr(ref, "tool_class") else None
+            if tool_class is None:
+                return True
+
+        return False
+
+    def _get_platform_tool_error(self, ref: Any) -> str:
+        """Get error message for platform tools.
+
+        Args:
+            ref: Platform tool reference.
+
+        Returns:
+            Error message string.
+        """
+        from glaip_sdk.runner.deps import (  # noqa: PLC0415
+            get_local_mode_not_supported_for_tool_message,
+        )
+
+        tool_name = ref if isinstance(ref, str) else getattr(ref, "name", None)
+        if tool_name is None:
+            tool_name = getattr(getattr(ref, "tool_class", None), "__name__", _UNKNOWN_TOOL_NAME)
+        return get_local_mode_not_supported_for_tool_message(tool_name)