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

solace_agent_mesh/agent/adk/runner.py

@@ -73,18 +73,21 @@ async def run_adk_async_task_thread_wrapper(
 
         if adk_session and component.session_service:
             context_setting_invocation_id = logical_task_id
-            context_setting_event = ADKEvent(
-                invocation_id=context_setting_invocation_id,
-                author="A2A_Host_System",
-                content=adk_types.Content(
-                    parts=[
-                        adk_types.Part(text="Initializing A2A context for task run.")
-                    ]
-                ),
-                actions=EventActions(state_delta={"a2a_context": a2a_context}),
-                branch=None,
-            )
+            original_message = a2a_context.pop("original_solace_message", None)
             try:
+                context_setting_event = ADKEvent(
+                    invocation_id=context_setting_invocation_id,
+                    author="A2A_Host_System",
+                    content=adk_types.Content(
+                        parts=[
+                            adk_types.Part(
+                                text="Initializing A2A context for task run."
+                            )
+                        ]
+                    ),
+                    actions=EventActions(state_delta={"a2a_context": a2a_context}),
+                    branch=None,
+                )
                 await component.session_service.append_event(
                     session=adk_session, event=context_setting_event
                 )
@@ -96,12 +99,15 @@ async def run_adk_async_task_thread_wrapper(
                 )
             except Exception as e_append:
                 log.error(
-                    "%s Failed to append context-setting event for task %s: %s. Tool scope filtering might not work if state is not persisted.",
+                    "%s Failed to append context-setting event for task %s: %s.",
                     component.log_identifier,
                     logical_task_id,
                     e_append,
                     exc_info=True,
                 )
+            finally:
+                if original_message:
+                    a2a_context["original_solace_message"] = original_message
         else:
             log.warning(
                 "%s Could not inject a2a_context into ADK session state via event for task %s (session or session_service invalid). Tool scope filtering might not work.",

solace_agent_mesh/agent/adk/services.py

@@ -174,11 +174,11 @@ def initialize_session_service(component) -> BaseSessionService:
 
     if service_type == "memory":
         return InMemorySessionService()
-    elif service_type == "database":
-        db_url = config.get("db_url")
+    elif service_type == "sql":
+        db_url = config.get("database_url")
         if not db_url:
             raise ValueError(
-                f"{component.log_identifier} 'db_url' is required for database session service."
+                f"{component.log_identifier} 'database_url' is required for sql session service."
             )
         try:
             return DatabaseSessionService(db_url=db_url)

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/protocol/event_handlers.py

@@ -229,27 +229,6 @@ async def handle_a2a_request(component, message: SolaceMessage):
         component.log_identifier,
         message.get_topic(),
     )
-    a2a_context = {}
-    adk_session = None
-    jsonrpc_request_id = None
-    logical_task_id = None
-    client_id = message.get_user_properties().get("clientId", "default_client")
-    status_topic_from_peer = message.get_user_properties().get("a2aStatusTopic")
-    reply_topic_from_peer = message.get_user_properties().get("replyTo")
-    namespace = component.get_config("namespace")
-    a2a_user_config = message.get_user_properties().get("a2aUserConfig", {})
-    if not isinstance(a2a_user_config, dict):
-        log.warning(
-            "%s 'a2aUserConfig' user property is not a dictionary, received: %s. Defaulting to empty dict.",
-            component.log_identifier,
-            type(a2a_user_config),
-        )
-        a2a_user_config = {}
-    log.debug(
-        "%s Extracted 'a2aUserConfig': %s",
-        component.log_identifier,
-        a2a_user_config,
-    )
     try:
         payload_dict = message.get_payload()
         if not isinstance(payload_dict, dict):
@@ -257,6 +236,16 @@ async def handle_a2a_request(component, message: SolaceMessage):
         a2a_request: A2ARequest = A2ARequest.model_validate(payload_dict)
         jsonrpc_request_id = a2a.get_request_id(a2a_request)
 
+        # Extract properties from message user properties  
+        client_id = message.get_user_properties().get("clientId", "default_client")
+        status_topic_from_peer = message.get_user_properties().get("a2aStatusTopic")
+        reply_topic_from_peer = message.get_user_properties().get("replyTo")
+        namespace = component.get_config("namespace")
+        a2a_user_config = message.get_user_properties().get("a2aUserConfig", {})
+        if not isinstance(a2a_user_config, dict):
+            log.warning("a2aUserConfig is not a dict, using empty dict instead")
+            a2a_user_config = {}
+
         # The concept of logical_task_id changes. For Cancel, it's in params.id.
         # For Send, we will generate it.
         logical_task_id = None
@@ -411,6 +400,20 @@ async def handle_a2a_request(component, message: SolaceMessage):
             effective_session_id = original_session_id
             is_run_based_session = False
             temporary_run_session_id_for_cleanup = None
+
+            session_id_from_data = None
+            if a2a_message and a2a_message.parts:
+                for part in a2a_message.parts:
+                    if isinstance(part, DataPart) and "session_id" in part.data:
+                        session_id_from_data = part.data["session_id"]
+                        log.info(
+                            f"Extracted session_id '{session_id_from_data}' from DataPart."
+                        )
+                        break
+
+            if session_id_from_data:
+                original_session_id = session_id_from_data
+
             if session_behavior == "RUN_BASED":
                 is_run_based_session = True
                 effective_session_id = f"{original_session_id}:{logical_task_id}:run"
@@ -432,6 +435,7 @@ async def handle_a2a_request(component, message: SolaceMessage):
                     effective_session_id,
                     logical_task_id,
                 )
+
             adk_session_for_run = await component.session_service.get_session(
                 app_name=agent_name, user_id=user_id, session_id=effective_session_id
             )
@@ -447,6 +451,7 @@ async def handle_a2a_request(component, message: SolaceMessage):
                     effective_session_id,
                     logical_task_id,
                 )
+
             else:
                 log.info(
                     "%s Reusing existing ADK session '%s' for task '%s'.",
@@ -454,6 +459,7 @@ async def handle_a2a_request(component, message: SolaceMessage):
                     effective_session_id,
                     logical_task_id,
                 )
+
             if is_run_based_session:
                 try:
                     original_adk_session_data = (

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,

solace_agent_mesh/agent/sac/component.py

@@ -12,7 +12,6 @@ import fnmatch
 import base64
 from datetime import datetime, timezone
 import json
-import json
 from solace_ai_connector.common.message import (
     Message as SolaceMessage,
 )

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