solace-agent-mesh 1.3.0__py3-none-any.whl → 1.3.1__py3-none-any.whl

solace_agent_mesh/agent/adk/setup.py

@@ -18,7 +18,6 @@ from google.adk import tools as adk_tools_module
 from google.adk.agents.callback_context import CallbackContext
 from google.adk.models.llm_request import LlmRequest
 from google.adk.models.llm_response import LlmResponse
-from google.adk.tools.mcp_tool import MCPToolset
 from google.adk.tools.mcp_tool.mcp_session_manager import (
     SseServerParams,
     StdioConnectionParams,
@@ -28,12 +27,49 @@ from mcp import StdioServerParameters
 
 from ..tools.registry import tool_registry
 from ..tools.tool_definition import BuiltinTool
+from ..tools.dynamic_tool import DynamicTool, DynamicToolProvider
 
 
 from ...agent.adk import callbacks as adk_callbacks
 from ...agent.adk.models.lite_llm import LiteLlm
 
 
+def _find_dynamic_tool_class(module) -> Optional[type]:
+    """Finds a single non-abstract DynamicTool subclass in a module."""
+    found_classes = []
+    for name, obj in inspect.getmembers(module, inspect.isclass):
+        if (
+            issubclass(obj, DynamicTool)
+            and obj is not DynamicTool
+            and not inspect.isabstract(obj)
+        ):
+            found_classes.append(obj)
+    if len(found_classes) > 1:
+        raise TypeError(
+            f"Module '{module.__name__}' contains multiple DynamicTool subclasses. "
+            "Please specify which one to use with 'class_name' in the config."
+        )
+    return found_classes[0] if found_classes else None
+
+
+def _find_dynamic_tool_provider_class(module) -> Optional[type]:
+    """Finds a single non-abstract DynamicToolProvider subclass in a module."""
+    found_classes = []
+    for name, obj in inspect.getmembers(module, inspect.isclass):
+        if (
+            issubclass(obj, DynamicToolProvider)
+            and obj is not DynamicToolProvider
+            and not inspect.isabstract(obj)
+        ):
+            found_classes.append(obj)
+    if len(found_classes) > 1:
+        raise TypeError(
+            f"Module '{module.__name__}' contains multiple DynamicToolProvider subclasses. "
+            "Only one is permitted per module."
+        )
+    return found_classes[0] if found_classes else None
+
+
 async def load_adk_tools(
     component,
 ) -> Tuple[List[Union[BaseTool, Callable]], List[BuiltinTool]]:
@@ -90,48 +126,119 @@ async def load_adk_tools(
             try:
                 if tool_type == "python":
                     module_name = tool_config.get("component_module")
-                    function_name = tool_config.get("function_name")
-                    tool_name = tool_config.get("tool_name")
-                    tool_description = tool_config.get("tool_description")
                     base_path = tool_config.get("component_base_path")
-                    if not module_name or not function_name:
+                    if not module_name:
                         raise ValueError(
-                            "'component_module' and 'function_name' required for python tool."
+                            "'component_module' is required for python tools."
                         )
-
                     module = import_module(module_name, base_path=base_path)
-                    func = getattr(module, function_name)
-                    if not callable(func):
-                        raise TypeError(
-                            f"'{function_name}' in module '{module_name}' is not callable."
+
+                    # Case 1: Simple function-based tool
+                    if "function_name" in tool_config:
+                        function_name = tool_config.get("function_name")
+                        tool_name = tool_config.get("tool_name")
+                        tool_description = tool_config.get("tool_description")
+
+                        func = getattr(module, function_name)
+                        if not callable(func):
+                            raise TypeError(
+                                f"'{function_name}' in module '{module_name}' is not callable."
+                            )
+
+                        specific_tool_config = tool_config.get("tool_config")
+                        tool_callable = ADKToolWrapper(
+                            func,
+                            specific_tool_config,
+                            function_name,
+                            origin="python",
+                            raw_string_args=tool_config.get("raw_string_args", []),
                         )
 
-                    specific_tool_config = tool_config.get("tool_config")
-                    tool_callable = ADKToolWrapper(
-                        func,
-                        specific_tool_config,
-                        function_name,
-                        origin="python",
-                        raw_string_args=tool_config.get("raw_string_args", []),
-                    )
+                        if tool_name:
+                            function_name = tool_name
+                            tool_callable.__name__ = tool_name
+
+                        if tool_description:
+                            tool_callable.__doc__ = tool_description
+
+                        _check_and_register_tool_name(
+                            function_name, f"python:{module_name}"
+                        )
+                        loaded_tools.append(tool_callable)
+                        log.info(
+                            "%s Loaded Python tool: %s from %s.",
+                            component.log_identifier,
+                            function_name,
+                            module_name,
+                        )
+                    # Case 2: Advanced class-based dynamic tool or provider
+                    else:
+                        specific_tool_config = tool_config.get("tool_config")
+                        dynamic_tools = []
 
-                    if tool_name:
-                        function_name = tool_name
-                        tool_callable.__name__ = tool_name
+                        # Determine the class to load
+                        tool_class = None
+                        class_name = tool_config.get("class_name")
+                        if class_name:
+                            tool_class = getattr(module, class_name)
+                        else:
+                            # Auto-discover: provider first, then single tool
+                            tool_class = _find_dynamic_tool_provider_class(module)
+                            if not tool_class:
+                                tool_class = _find_dynamic_tool_class(module)
+
+                        if not tool_class:
+                            raise TypeError(
+                                f"Module '{module_name}' does not contain a 'function_name' or 'class_name' to load, "
+                                "and no DynamicTool or DynamicToolProvider subclass could be auto-discovered."
+                            )
 
-                    if tool_description:
-                        tool_callable.__doc__ = tool_description
+                        # Instantiate tools from the class
+                        if issubclass(tool_class, DynamicToolProvider):
+                            provider_instance = tool_class()
+                            dynamic_tools = (
+                                provider_instance.get_all_tools_for_framework(
+                                    tool_config=specific_tool_config
+                                )
+                            )
+                            log.info(
+                                "%s Loaded %d tools from DynamicToolProvider '%s' in %s",
+                                component.log_identifier,
+                                len(dynamic_tools),
+                                tool_class.__name__,
+                                module_name,
+                            )
+                        elif issubclass(tool_class, DynamicTool):
+                            tool_instance = tool_class(tool_config=specific_tool_config)
+                            dynamic_tools = [tool_instance]
+                        else:
+                            raise TypeError(
+                                f"Class '{tool_class.__name__}' in module '{module_name}' is not a valid "
+                                "DynamicTool or DynamicToolProvider subclass."
+                            )
 
-                    _check_and_register_tool_name(
-                        function_name, f"python:{module_name}"
-                    )
-                    loaded_tools.append(tool_callable)
-                    log.info(
-                        "%s Loaded Python tool: %s from %s.",
-                        component.log_identifier,
-                        function_name,
-                        module_name,
-                    )
+                        # Process all generated tools
+                        for tool in dynamic_tools:
+                            tool.origin = "dynamic"
+                            declaration = tool._get_declaration()
+                            if not declaration:
+                                log.warning(
+                                    "Dynamic tool '%s' from module '%s' did not generate a valid declaration. Skipping.",
+                                    tool.__class__.__name__,
+                                    module_name,
+                                )
+                                continue
+
+                            _check_and_register_tool_name(
+                                declaration.name, f"dynamic:{module_name}"
+                            )
+                            loaded_tools.append(tool)
+                            log.info(
+                                "%s Loaded dynamic tool: %s from %s",
+                                component.log_identifier,
+                                declaration.name,
+                                module_name,
+                            )
 
                 elif tool_type == "builtin":
                     tool_name = tool_config.get("tool_name")

solace_agent_mesh/agent/sac/app.py

@@ -14,7 +14,6 @@ patch_adk()
 
 from typing import Any, Dict
 from solace_ai_connector.flow.app import App
-from solace_ai_connector.common.log import log
 
 from ...common.a2a import (
     get_agent_request_topic,
@@ -714,4 +713,4 @@ class SamAgentApp(App):
         log.debug("Set broker_config.temporary_queue = True")
 
         super().__init__(app_info, **kwargs)
-        log.debug("A2A_ADK_App initialization complete.")
+        log.debug("A2A_ADK_App initialization complete.")

solace_agent_mesh/agent/tools/__init__.py

@@ -12,3 +12,4 @@ from . import audio_tools
 from . import image_tools
 from . import web_tools
 from . import test_tools
+from . import dynamic_tool

solace_agent_mesh/agent/tools/dynamic_tool.py

@@ -0,0 +1,362 @@
+"""
+Defines the base classes and helpers for "dynamic" tools.
+Dynamic tools allow for programmatic definition of tool names, descriptions,
+and parameter schemas, offering more flexibility than standard Python tools.
+"""
+
+from abc import ABC, abstractmethod
+from typing import (
+    Optional,
+    List,
+    Callable,
+    Dict,
+    Any,
+    get_origin,
+    get_args,
+    Union,
+    Literal,
+)
+import inspect
+
+from google.adk.tools import BaseTool, ToolContext
+from google.genai import types as adk_types
+from solace_ai_connector.common.log import log
+
+from solace_agent_mesh.agent.utils.context_helpers import get_original_session_id
+
+from ...common.utils.embeds import (
+    resolve_embeds_in_string,
+    evaluate_embed,
+    EARLY_EMBED_TYPES,
+    LATE_EMBED_TYPES,
+    EMBED_DELIMITER_OPEN,
+)
+
+
+# --- Base Class for Programmatic Tools ---
+
+
+class DynamicTool(BaseTool, ABC):
+    """
+    Base class for dynamic tools that can define their own function names,
+    descriptions, and parameter schemas programmatically.
+    """
+
+    def __init__(self, tool_config: Optional[dict] = None):
+        # Initialize with placeholder values, will be overridden by properties
+        super().__init__(
+            name="dynamic_tool_placeholder", description="dynamic_tool_placeholder"
+        )
+        self.tool_config = tool_config or {}
+
+    @property
+    @abstractmethod
+    def tool_name(self) -> str:
+        """Return the function name that the LLM will call."""
+        pass
+
+    @property
+    @abstractmethod
+    def tool_description(self) -> str:
+        """Return the description of what this tool does."""
+        pass
+
+    @property
+    @abstractmethod
+    def parameters_schema(self) -> adk_types.Schema:
+        """Return the ADK Schema defining the tool's parameters."""
+        pass
+
+    @property
+    def raw_string_args(self) -> List[str]:
+        """
+        Return a list of argument names that should not have embeds resolved.
+        Subclasses can override this property.
+        """
+        return []
+
+    @property
+    def resolution_type(self) -> Literal["early", "all"]:
+        """
+        Determines which embeds to resolve. 'early' resolves simple embeds like
+        math and uuid. 'all' also resolves 'artifact_content'.
+        Defaults to 'early'.
+        """
+        return "early"
+
+    def _get_declaration(self) -> Optional[Any]:
+        """
+        Generate the FunctionDeclaration for this dynamic tool.
+        This follows the same pattern as PeerAgentTool and MCP tools.
+        """
+        # Update the tool name to match what the module defines
+        self.name = self.tool_name
+
+        return adk_types.FunctionDeclaration(
+            name=self.tool_name,
+            description=self.tool_description,
+            parameters=self.parameters_schema,
+        )
+
+    async def run_async(
+        self, *, args: Dict[str, Any], tool_context: ToolContext
+    ) -> Dict[str, Any]:
+        """
+        Asynchronously runs the tool with the given arguments.
+        This method resolves embeds in arguments and then delegates the call
+        to the abstract _run_async_impl.
+        """
+        log_identifier = f"[DynamicTool:{self.tool_name}]"
+        resolved_kwargs = args.copy()
+
+        types_to_resolve = EARLY_EMBED_TYPES
+        if self.resolution_type == "all":
+            types_to_resolve = EARLY_EMBED_TYPES.union(LATE_EMBED_TYPES)
+
+        # Unlike ADKToolWrapper, DynamicTools receive all args in a single dict.
+        # We iterate through this dict to resolve embeds.
+        for key, value in args.items():
+            if key in self.raw_string_args and isinstance(value, str):
+                log.debug(
+                    "%s Skipping embed resolution for raw string kwarg '%s'",
+                    log_identifier,
+                    key,
+                )
+            elif isinstance(value, str) and EMBED_DELIMITER_OPEN in value:
+                log.debug("%s Resolving embeds for kwarg '%s'", log_identifier, key)
+                # Create the resolution context
+                if hasattr(tool_context, "_invocation_context"):
+                    # Use the invocation context if available
+                    invocation_context = tool_context._invocation_context
+                else:
+                    # Error if no invocation context is found
+                    raise RuntimeError(
+                        f"{log_identifier} No invocation context found in ToolContext. Cannot resolve embeds."
+                    )
+                session_context = invocation_context.session
+                if not session_context:
+                    raise RuntimeError(
+                        f"{log_identifier} No session context found in invocation context. Cannot resolve embeds."
+                    )
+                resolution_context = {
+                    "artifact_service": invocation_context.artifact_service,
+                    "session_context": {
+                        "session_id": get_original_session_id(invocation_context),
+                        "user_id": session_context.user_id,
+                        "app_name": session_context.app_name,
+                    },
+                }
+                resolved_value, _, _ = await resolve_embeds_in_string(
+                    text=value,
+                    context=resolution_context,
+                    resolver_func=evaluate_embed,
+                    types_to_resolve=types_to_resolve,
+                    log_identifier=log_identifier,
+                    config=self.tool_config,
+                )
+                resolved_kwargs[key] = resolved_value
+
+        return await self._run_async_impl(
+            args=resolved_kwargs, tool_context=tool_context, credential=None
+        )
+
+    @abstractmethod
+    async def _run_async_impl(
+        self, args: dict, tool_context: ToolContext, credential: Optional[str] = None
+    ) -> dict:
+        """
+        Implement the actual tool logic.
+        Must return a dictionary response.
+        """
+        pass
+
+
+# --- Internal Adapter for Function-Based Tools ---
+
+
+def _get_schema_from_signature(func: Callable) -> adk_types.Schema:
+    """
+    Introspects a function's signature and generates an ADK Schema for its parameters.
+    """
+    sig = inspect.signature(func)
+    properties = {}
+    required = []
+
+    type_map = {
+        str: adk_types.Type.STRING,
+        int: adk_types.Type.INTEGER,
+        float: adk_types.Type.NUMBER,
+        bool: adk_types.Type.BOOLEAN,
+        list: adk_types.Type.ARRAY,
+        dict: adk_types.Type.OBJECT,
+    }
+
+    for param in sig.parameters.values():
+        if param.name in ("tool_context", "tool_config", "kwargs", "self", "cls"):
+            continue
+
+        param_type = param.annotation
+        is_optional = False
+
+        # Handle Optional[T] which is Union[T, None]
+        origin = get_origin(param_type)
+        args = get_args(param_type)
+        if origin is Union and type(None) in args:
+            is_optional = True
+            # Get the actual type from Union[T, None]
+            param_type = next((t for t in args if t is not type(None)), Any)
+
+        adk_type = type_map.get(param_type)
+        if not adk_type:
+            # Default to string if type is not supported or specified (e.g., Any)
+            adk_type = adk_types.Type.STRING
+
+        properties[param.name] = adk_types.Schema(type=adk_type, nullable=is_optional)
+
+        if param.default is inspect.Parameter.empty and not is_optional:
+            required.append(param.name)
+
+    return adk_types.Schema(
+        type=adk_types.Type.OBJECT,
+        properties=properties,
+        required=required,
+    )
+
+
+class _FunctionAsDynamicTool(DynamicTool):
+    """
+    Internal adapter to wrap a standard Python function as a DynamicTool.
+    """
+
+    def __init__(
+        self,
+        func: Callable,
+        tool_config: Optional[dict] = None,
+        provider_instance: Optional[Any] = None,
+    ):
+        super().__init__(tool_config=tool_config)
+        self._func = func
+        self._provider_instance = provider_instance
+        self._schema = _get_schema_from_signature(func)
+
+        # Check if the function is an instance method that needs `self`
+        self._is_instance_method = False
+        sig = inspect.signature(self._func)
+        if sig.parameters:
+            first_param = next(iter(sig.parameters.values()))
+            if first_param.name == "self":
+                self._is_instance_method = True
+
+    @property
+    def tool_name(self) -> str:
+        return self._func.__name__
+
+    @property
+    def tool_description(self) -> str:
+        return inspect.getdoc(self._func) or ""
+
+    @property
+    def parameters_schema(self) -> adk_types.Schema:
+        return self._schema
+
+    async def _run_async_impl(
+        self,
+        args: dict,
+        tool_context: ToolContext,
+        credential: Optional[str] = None,
+    ) -> dict:
+        # Inject tool_context and tool_config if the function expects them
+        sig = inspect.signature(self._func)
+        if "tool_context" in sig.parameters:
+            args["tool_context"] = tool_context
+        if "tool_config" in sig.parameters:
+            args["tool_config"] = self.tool_config
+
+        if self._provider_instance and self._is_instance_method:
+            # It's an instance method, call it on the provider instance
+            return await self._func(self._provider_instance, **args)
+        else:
+            # It's a static method or a standalone function
+            return await self._func(**args)
+
+
+# --- Base Class for Tool Providers ---
+
+
+class DynamicToolProvider(ABC):
+    """
+    Base class for dynamic tool providers that can generate a list of tools
+    programmatically from a single configuration block.
+    """
+
+    _decorated_tools: List[Callable] = []
+
+    @classmethod
+    def register_tool(cls, func: Callable) -> Callable:
+        """
+        A decorator to register a standard async function as a tool.
+        The decorated function's signature and docstring will be used to
+        create the tool definition.
+        """
+        # This check is crucial. It runs for each decorated method.
+        # If the current class `cls` is using the list from the base class
+        # `DynamicToolProvider`, it creates a new, empty list just for `cls`.
+        # On subsequent decorator calls for the same `cls`, this condition will
+        # be false, and it will append to the existing list.
+        if (
+            not hasattr(cls, "_decorated_tools")
+            or cls._decorated_tools is DynamicToolProvider._decorated_tools
+        ):
+            cls._decorated_tools = []
+
+        cls._decorated_tools.append(func)
+        return func
+
+    def _create_tools_from_decorators(
+        self, tool_config: Optional[dict] = None
+    ) -> List[DynamicTool]:
+        """
+        Internal helper to convert decorated functions into DynamicTool instances.
+        """
+        tools = []
+        for func in self._decorated_tools:
+            adapter = _FunctionAsDynamicTool(func, tool_config, provider_instance=self)
+            tools.append(adapter)
+        return tools
+
+    def get_all_tools_for_framework(
+        self, tool_config: Optional[dict] = None
+    ) -> List[DynamicTool]:
+        """
+        Framework-internal method that automatically combines decorated tools with custom tools.
+        This is called by the ADK setup code, not by users.
+
+        Args:
+            tool_config: The configuration dictionary from the agent's YAML file.
+
+        Returns:
+            A list of all DynamicTool objects (decorated + custom).
+        """
+        # Get tools from decorators automatically
+        decorated_tools = self._create_tools_from_decorators(tool_config)
+
+        # Get custom tools from the user's implementation
+        custom_tools = self.create_tools(tool_config)
+
+        return decorated_tools + custom_tools
+
+    @abstractmethod
+    def create_tools(self, tool_config: Optional[dict] = None) -> List[DynamicTool]:
+        """
+        Generate and return a list of custom DynamicTool instances.
+
+        Note: Tools registered with the @register_tool decorator are automatically
+        included by the framework - you don't need to handle them here.
+
+        Args:
+            tool_config: The configuration dictionary from the agent's YAML file.
+
+        Returns:
+            A list of custom DynamicTool objects (decorated tools are added automatically).
+        """
+        pass