solace-agent-mesh 1.6.1__py3-none-any.whl → 1.13.2__py3-none-any.whl

solace_agent_mesh/agent/adk/setup.py

@@ -2,50 +2,58 @@
 Handles ADK Agent and Runner initialization, including tool loading and callback assignment.
 """
 
-import logging
-from typing import Dict, List, Optional, Union, Callable, Tuple, Set, Any, TYPE_CHECKING, Type
 import functools
 import inspect
-from solace_ai_connector.common.utils import import_module
-from ...common.utils.type_utils import is_subclass_by_name
-
+import logging
+import os
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    Union,
+)
 
-from .app_llm_agent import AppLlmAgent
-from .tool_wrapper import ADKToolWrapper
-from .embed_resolving_mcp_toolset import EmbedResolvingMCPToolset
-from google.adk.runners import Runner
-from google.adk.models import BaseLlm
-from google.adk.tools import BaseTool, ToolContext
 from google.adk import tools as adk_tools_module
 from google.adk.agents.callback_context import CallbackContext
+from google.adk.models import BaseLlm
 from google.adk.models.llm_request import LlmRequest
 from google.adk.models.llm_response import LlmResponse
+from google.adk.runners import Runner
+from google.adk.tools import BaseTool, ToolContext
+from google.adk.tools.mcp_tool import MCPTool
 from google.adk.tools.mcp_tool.mcp_session_manager import (
     SseServerParams,
     StdioConnectionParams,
     StreamableHTTPServerParams,
-
 )
-
 from mcp import StdioServerParameters
+from solace_ai_connector.common.utils import import_module
 
-if TYPE_CHECKING:
-    from ..sac.component import SamAgentComponent
-
-from ..tools.registry import tool_registry
-from ..tools.tool_definition import BuiltinTool
+from ...agent.adk import callbacks as adk_callbacks
+from ...agent.adk.models.lite_llm import LiteLlm
+from ...common.utils.type_utils import is_subclass_by_name
 from ..tools.dynamic_tool import DynamicTool, DynamicToolProvider
+from ..tools.registry import tool_registry
 from ..tools.tool_config_types import (
     AnyToolConfig,
-    BuiltinToolConfig,
     BuiltinGroupToolConfig,
+    BuiltinToolConfig,
     McpToolConfig,
     PythonToolConfig,
 )
+from ..tools.tool_definition import BuiltinTool
+from .app_llm_agent import AppLlmAgent
+from .embed_resolving_mcp_toolset import EmbedResolvingMCPToolset
+from .tool_wrapper import ADKToolWrapper
 
-
-from ...agent.adk import callbacks as adk_callbacks
-from ...agent.adk.models.lite_llm import LiteLlm
+if TYPE_CHECKING:
+    from ..sac.component import SamAgentComponent
 
 log = logging.getLogger(__name__)
 
@@ -488,7 +496,16 @@ async def _load_builtin_group_tool(component: "SamAgentComponent", tool_config:
     loaded_tools: List[Union[BaseTool, Callable]] = []
     enabled_builtin_tools: List[BuiltinTool] = []
     for tool_def in tools_in_group:
+        # Try to get tool-specific config, but fall back to the entire tool_config
+        # This allows both patterns:
+        # 1. tool_config with keys at top level (e.g., api_key: "xxx")
+        # 2. tool_config with nested configs per tool (e.g., tool_name: {api_key: "xxx"})
         specific_tool_config = tool_config_model.tool_config.get(tool_def.name)
+        if specific_tool_config is None:
+            # No tool-specific config found, use the entire tool_config
+            # This is the common case for groups where all tools share the same config
+            specific_tool_config = tool_config_model.tool_config
+        
         tool_callable = ADKToolWrapper(
             tool_def.implementation,
             specific_tool_config,
@@ -506,6 +523,35 @@ async def _load_builtin_group_tool(component: "SamAgentComponent", tool_config:
     )
     return loaded_tools, enabled_builtin_tools, []
 
+def validate_filesystem_path(path, log_identifier=""):
+    """
+    Validates that a filesystem path exists and is accessible.
+
+    Args:
+        path: The filesystem path to validate
+        log_identifier: Optional identifier for logging
+
+    Returns:
+        bool: True if the path exists and is accessible, False otherwise
+
+    Raises:
+        ValueError: If the path doesn't exist or isn't accessible
+    """
+    if not path:
+        raise ValueError(f"{log_identifier} Filesystem path is empty or None")
+
+    if not os.path.exists(path):
+        raise ValueError(f"{log_identifier} Filesystem path does not exist: {path}")
+
+    if not os.path.isdir(path):
+        raise ValueError(f"{log_identifier} Filesystem path is not a directory: {path}")
+
+    # Check if the directory is readable and writable
+    if not os.access(path, os.R_OK | os.W_OK):
+        raise ValueError(f"{log_identifier} Filesystem path is not readable and writable: {path}")
+
+    return True
+
 async def _load_mcp_tool(component: "SamAgentComponent", tool_config: Dict) -> ToolLoadingResult:
     """Loads an MCP toolset based on connection parameters."""
     from pydantic import TypeAdapter
@@ -553,6 +599,31 @@ async def _load_mcp_tool(component: "SamAgentComponent", tool_config: Dict) -> T
             raise ValueError(
                 f"MCP tool 'args' parameter must be a list, got {type(args_list)}"
             )
+
+        # Check if this is the filesystem MCP server
+        if args_list and any("@modelcontextprotocol/server-filesystem" in arg for arg in args_list):
+            # Find the index of the server-filesystem argument
+            server_fs_index = -1
+            for i, arg in enumerate(args_list):
+                if "@modelcontextprotocol/server-filesystem" in arg:
+                    server_fs_index = i
+                    break
+
+            # All arguments after server-filesystem are directory paths
+            if server_fs_index >= 0 and server_fs_index + 1 < len(args_list):
+                directory_paths = args_list[server_fs_index + 1:]
+
+                for path in directory_paths:
+                    try:
+                        validate_filesystem_path(path, log_identifier=component.log_identifier)
+                        log.info(
+                            "%s Validated filesystem path for MCP server: %s",
+                            component.log_identifier,
+                            path
+                        )
+                    except ValueError as e:
+                        log.error("%s", str(e))
+                        raise ValueError(f"MCP filesystem server path validation failed: {e}")
         final_connection_args = {
             k: v
             for k, v in connection_args.items()
@@ -575,32 +646,153 @@ async def _load_mcp_tool(component: "SamAgentComponent", tool_config: Dict) -> T
     else:
         raise ValueError(f"Unsupported MCP connection type: {connection_type}")
 
-    tool_filter_list = (
-        [tool_config_model.tool_name] if tool_config_model.tool_name else None
-    )
-    if tool_filter_list:
+    # Determine tool filter based on configuration
+    # tool_name, allow_list, and deny_list are mutually exclusive (validated by pydantic)
+    tool_filter = None
+    filter_description = "none (all tools)"
+
+    if tool_config_model.tool_name:
+        # Backward compatible: single tool name becomes a list
+        tool_filter = [tool_config_model.tool_name]
+        filter_description = f"tool_name='{tool_config_model.tool_name}'"
+    elif tool_config_model.allow_list:
+        # Allow list: pass directly as list of tool names
+        tool_filter = tool_config_model.allow_list
+        filter_description = f"allow_list={tool_config_model.allow_list}"
+    elif tool_config_model.deny_list:
+        # Deny list: create a ToolPredicate that excludes these tools
+        deny_set = set(tool_config_model.deny_list)
+        tool_filter = lambda tool, ctx=None, _deny=deny_set: tool.name not in _deny
+        filter_description = f"deny_list={tool_config_model.deny_list}"
+
+    if tool_filter:
         log.info(
-            "%s MCP tool config specifies tool_name: '%s'. Applying as tool_filter.",
+            "%s MCP tool config specifies filter: %s",
             component.log_identifier,
-            tool_config_model.tool_name,
+            filter_description,
         )
 
-    mcp_toolset_instance = EmbedResolvingMCPToolset(
-        connection_params=connection_params,
-        tool_filter=tool_filter_list,
-        tool_config=tool_config,
-    )
+    additional_params = {}
+    try:
+        from solace_agent_mesh_enterprise.auth.tool_configurator import (
+            configure_mcp_tool,
+        )
+
+        try:
+            # Call the tool configurator with MCP-specific context
+            additional_params = configure_mcp_tool(
+                tool_type="mcp",
+                tool_config=tool_config,
+                connection_params=connection_params,
+                tool_filter=tool_filter,
+            )
+        except Exception as e:
+            log.error(
+                "%s Tool configurator failed for %s: %s",
+                component.log_identifier,
+                tool_config.get("name", "unknown"),
+                e,
+            )
+            # Continue with normal tool creation if configurator fails
+            additional_params = {}
+    except ImportError:
+        pass
+
+    # Create the EmbedResolvingMCPToolset with base parameters
+    toolset_params = {
+        "connection_params": connection_params,
+        "tool_filter": tool_filter,
+        "tool_name_prefix": tool_config_model.tool_name_prefix,
+        "tool_config": tool_config,
+    }
+
+    # Merge additional parameters from configurator
+    toolset_params.update(additional_params)
+
+    mcp_toolset_instance = EmbedResolvingMCPToolset(**toolset_params)
     mcp_toolset_instance.origin = "mcp"
 
     log.info(
-        "%s Initialized MCPToolset (filter: %s) for server: %s",
-        component.log_identifier,
-        (tool_filter_list if tool_filter_list else "none (all tools)"),
-        connection_params,
+            "%s Initialized MCPToolset (filter: %s) for server: %s",
+            component.log_identifier,
+            filter_description,
+            connection_params,
     )
 
     return [mcp_toolset_instance], [], []
 
+
+async def _load_openapi_tool(component: "SamAgentComponent", tool_config: Dict) -> ToolLoadingResult:
+    """
+    Loads an OpenAPI toolset by delegating to the enterprise configurator.
+
+    This function validates the tool configuration and attempts to load the OpenAPI tool
+    using the enterprise package. If the enterprise package is not available, it logs a
+    warning and returns empty results.
+
+    Args:
+        component: The SamAgentComponent instance
+        tool_config: Dictionary containing the tool's configuration
+
+    Returns:
+        ToolLoadingResult: Tuple of (tools, builtins, cleanup_hooks)
+                          Returns ([], [], []) if enterprise package not available
+    """
+    from pydantic import TypeAdapter
+
+    from ..tools.tool_config_types import OpenApiToolConfig
+
+    # Validate basic tool configuration structure
+    openapi_tool_adapter = TypeAdapter(OpenApiToolConfig)
+    try:
+        tool_config_model = openapi_tool_adapter.validate_python(tool_config)
+    except Exception as e:
+        log.error(
+            "%s Invalid OpenAPI tool configuration: %s",
+            component.log_identifier,
+            e,
+        )
+        raise
+
+    # Try to load the tool using the enterprise configurator
+    try:
+        from solace_agent_mesh_enterprise.auth.tool_configurator import (
+            configure_openapi_tool,
+        )
+
+        try:
+            openapi_toolset = configure_openapi_tool(
+                tool_type="openapi",
+                tool_config=tool_config,
+            )
+            openapi_toolset.origin = "openapi"
+
+            log.info(
+                "%s Loaded OpenAPI toolset via enterprise configurator",
+                component.log_identifier,
+            )
+
+            return [openapi_toolset], [], []
+
+        except Exception as e:
+            log.error(
+                "%s Failed to create OpenAPI tool %s: %s",
+                component.log_identifier,
+                tool_config.get("name", "unknown"),
+                e,
+            )
+            raise
+
+    except ImportError:
+        log.warning(
+            "%s OpenAPI tools require the solace-agent-mesh-enterprise package. "
+            "Skipping tool configuration: %s",
+            component.log_identifier,
+            tool_config.get("name", "unknown"),
+        )
+        return [], [], []
+
+
 def _load_internal_tools(component: "SamAgentComponent", loaded_tool_names: Set[str]) -> ToolLoadingResult:
     """Loads internal framework tools that are not explicitly configured by the user."""
     loaded_tools: List[Union[BaseTool, Callable]] = []
@@ -722,6 +914,12 @@ async def load_adk_tools(
                         new_builtins,
                         new_cleanups,
                     ) = await _load_mcp_tool(component, tool_config)
+                elif tool_type == "openapi":
+                    (
+                        new_tools,
+                        new_builtins,
+                        new_cleanups,
+                    ) = await _load_openapi_tool(component, tool_config)
                 else:
                     log.warning(
                         "%s Unknown tool type '%s' in config: %s",
@@ -734,19 +932,7 @@ async def load_adk_tools(
                 for tool in new_tools:
                     if isinstance(tool, EmbedResolvingMCPToolset):
                         # Special handling for MCPToolset which can load multiple tools
-                        try:
-                            mcp_tools = await tool.get_tools()
-                            for mcp_tool in mcp_tools:
-                                _check_and_register_tool_name(
-                                    mcp_tool.name, "mcp", loaded_tool_names
-                                )
-                        except Exception as e:
-                            log.error(
-                                "%s Failed to discover tools from MCP server for name registration: %s",
-                                component.log_identifier,
-                                str(e),
-                            )
-                            raise
+                        await _check_and_register_tool_name_mcp(component, loaded_tool_names, tool)
                     else:
                         tool_name = getattr(
                             tool, "name", getattr(tool, "__name__", None)
@@ -790,6 +976,25 @@ async def load_adk_tools(
     return loaded_tools, enabled_builtin_tools, cleanup_hooks
 
 
+async def _check_and_register_tool_name_mcp(component, loaded_tool_names: set[str], tool: EmbedResolvingMCPToolset):
+    try:
+        mcp_tools: list[MCPTool] = await tool.get_tools()
+        for mcp_tool in mcp_tools:
+            toolname = mcp_tool.name
+            if tool.tool_name_prefix != None:
+                toolname = f"{tool.tool_name_prefix}_{toolname}"
+            _check_and_register_tool_name(
+                toolname, "mcp", loaded_tool_names
+            )
+    except Exception as e:
+        log.error(
+            "%s Failed to discover tools from MCP server for name registration: %s",
+            component.log_identifier,
+            str(e),
+        )
+        raise
+
+
 def initialize_adk_agent(
     component,
     loaded_explicit_tools: List[Union[BaseTool, Callable]],
@@ -891,7 +1096,7 @@ def initialize_adk_agent(
         callbacks_in_order_for_before_model.append(
             adk_callbacks.repair_history_callback
         )
-        log.info(
+        log.debug(
             "%s Added repair_history_callback to before_model chain.",
             component.log_identifier,
         )
@@ -900,7 +1105,7 @@ def initialize_adk_agent(
             callbacks_in_order_for_before_model.append(
                 component._inject_peer_tools_callback
             )
-            log.info(
+            log.debug(
                 "%s Added _inject_peer_tools_callback to before_model chain.",
                 component.log_identifier,
             )
@@ -909,7 +1114,7 @@ def initialize_adk_agent(
             callbacks_in_order_for_before_model.append(
                 component._filter_tools_by_capability_callback
             )
-            log.info(
+            log.debug(
                 "%s Added _filter_tools_by_capability_callback to before_model chain.",
                 component.log_identifier,
             )
@@ -917,7 +1122,7 @@ def initialize_adk_agent(
             callbacks_in_order_for_before_model.append(
                 component._inject_gateway_instructions_callback
             )
-            log.info(
+            log.debug(
                 "%s Added _inject_gateway_instructions_callback to before_model chain.",
                 component.log_identifier,
             )
@@ -930,7 +1135,7 @@ def initialize_adk_agent(
         callbacks_in_order_for_before_model.append(
             dynamic_instruction_callback_with_component
         )
-        log.info(
+        log.debug(
             "%s Added inject_dynamic_instructions_callback to before_model chain.",
             component.log_identifier,
         )
@@ -957,7 +1162,7 @@ def initialize_adk_agent(
             return None
 
         agent.before_model_callback = final_before_model_wrapper
-        log.info(
+        log.debug(
             "%s Final before_model_callback chain (Solace logging now occurs last) assigned to agent.",
             component.log_identifier,
         )
@@ -967,7 +1172,7 @@ def initialize_adk_agent(
             host_component=component,
         )
         agent.before_tool_callback = tool_invocation_start_cb_with_component
-        log.info(
+        log.debug(
             "%s Assigned notify_tool_invocation_start_callback as before_tool_callback.",
             component.log_identifier,
         )
@@ -1053,7 +1258,7 @@ def initialize_adk_agent(
                 return tool_response
 
         agent.after_tool_callback = chained_after_tool_callback
-        log.info(
+        log.debug(
             "%s Chained 'manage_large_mcp_tool_responses_callback' and 'after_tool_callback_inject_metadata' as after_tool_callback.",
             component.log_identifier,
         )
@@ -1062,33 +1267,43 @@ def initialize_adk_agent(
         # The callbacks are executed in the order they are added to this list.
         callbacks_in_order_for_after_model = []
 
-        # 1. Fenced Artifact Block Processing (must run before auto-continue)
+        # 1. Pre-register long-running tools (must run BEFORE tool execution)
+        preregister_cb = functools.partial(
+            adk_callbacks.preregister_long_running_tools_callback, host_component=component
+        )
+        callbacks_in_order_for_after_model.append(preregister_cb)
+        log.debug(
+            "%s Added preregister_long_running_tools_callback to after_model chain.",
+            component.log_identifier,
+        )
+
+        # 2. Fenced Artifact Block Processing (must run before auto-continue)
         artifact_block_cb = functools.partial(
             adk_callbacks.process_artifact_blocks_callback, host_component=component
         )
         callbacks_in_order_for_after_model.append(artifact_block_cb)
-        log.info(
+        log.debug(
             "%s Added process_artifact_blocks_callback to after_model chain.",
             component.log_identifier,
         )
 
-        # 2. Auto-Continuation (may short-circuit the chain)
+        # 3. Auto-Continuation (may short-circuit the chain)
         auto_continue_cb = functools.partial(
             adk_callbacks.auto_continue_on_max_tokens_callback, host_component=component
         )
         callbacks_in_order_for_after_model.append(auto_continue_cb)
-        log.info(
+        log.debug(
             "%s Added auto_continue_on_max_tokens_callback to after_model chain.",
             component.log_identifier,
         )
 
-        # 3. Solace LLM Response Logging
+        # 4. Solace LLM Response Logging
         solace_llm_response_cb = functools.partial(
             adk_callbacks.solace_llm_response_callback, host_component=component
         )
         callbacks_in_order_for_after_model.append(solace_llm_response_cb)
 
-        # 4. Chunk Logging
+        # 5. Chunk Logging
         log_chunk_cb = functools.partial(
             adk_callbacks.log_streaming_chunk_callback, host_component=component
         )
@@ -1110,7 +1325,7 @@ def initialize_adk_agent(
             return None
 
         agent.after_model_callback = final_after_model_wrapper
-        log.info(
+        log.debug(
             "%s Chained all after_model_callbacks and assigned to agent.",
             component.log_identifier,
         )
@@ -1157,6 +1372,7 @@ def initialize_adk_runner(component) -> Runner:
             session_service=component.session_service,
             artifact_service=component.artifact_service,
             memory_service=component.memory_service,
+            credential_service=component.credential_service,
         )
         log.info("%s ADK Runner created successfully.", component.log_identifier)
         return runner