solace-agent-mesh 1.3.0__py3-none-any.whl → 1.3.2__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/protocol/event_handlers.py

@@ -32,7 +32,9 @@ from ...common.a2a import (
     get_client_response_topic,
     get_agent_response_subscription_topic,
     get_agent_status_subscription_topic,
+    get_sam_events_subscription_topic,
     get_text_from_message,
+    topic_matches_subscription,
 )
 from ...agent.utils.artifact_helpers import (
     generate_artifact_metadata_summary,
@@ -118,6 +120,7 @@ async def process_event(component, event: Event):
             agent_status_sub_prefix = (
                 get_agent_status_subscription_topic(namespace, agent_name)[:-2] + "/"
             )
+            sam_events_topic = get_sam_events_subscription_topic(namespace, "session")
             if topic == agent_request_topic:
                 await handle_a2a_request(component, message)
             elif topic == discovery_topic:
@@ -126,6 +129,8 @@ async def process_event(component, event: Event):
                     handle_agent_card_message(component, message)
                 else:
                     message.call_acknowledgements()
+            elif topic_matches_subscription(topic, sam_events_topic):
+                handle_sam_event(component, message, topic)
             elif topic.startswith(agent_response_sub_prefix) or topic.startswith(
                 agent_status_sub_prefix
             ):
@@ -233,6 +238,8 @@ async def handle_a2a_request(component, message: SolaceMessage):
         payload_dict = message.get_payload()
         if not isinstance(payload_dict, dict):
             raise ValueError("Payload is not a dictionary.")
+            
+            
         a2a_request: A2ARequest = A2ARequest.model_validate(payload_dict)
         jsonrpc_request_id = a2a.get_request_id(a2a_request)
 
@@ -1539,3 +1546,87 @@ def publish_agent_card(component):
             "%s Failed to publish Agent Card: %s", component.log_identifier, e
         )
         component.handle_error(e, None)
+
+
+def handle_sam_event(component, message, topic):
+    """Handle incoming SAM system events."""
+    try:
+        payload = message.get_payload()
+        
+        if not isinstance(payload, dict):
+            log.warning("Invalid SAM event payload - not a dict")
+            message.call_acknowledgements()
+            return
+        
+        event_type = payload.get("event_type")
+        if not event_type:
+            log.warning("SAM event missing event_type field")
+            message.call_acknowledgements()
+            return
+            
+        log.info("%s Received SAM event: %s", component.log_identifier, event_type)
+        
+        if event_type == "session.deleted":
+            data = payload.get("data", {})
+            session_id = data.get("session_id")
+            user_id = data.get("user_id")
+            agent_id = data.get("agent_id")
+            
+            if not all([session_id, user_id, agent_id]):
+                log.warning("Missing required fields in session.deleted event")
+                message.call_acknowledgements()
+                return
+                
+            current_agent = component.get_config("agent_name")
+            
+            if agent_id == current_agent:
+                log.info("%s Processing session.deleted event for session %s", 
+                        component.log_identifier, session_id)
+                asyncio.create_task(cleanup_agent_session(component, session_id, user_id))
+            else:
+                log.debug("Session deletion event for different agent: %s != %s", agent_id, current_agent)
+        else:
+            log.debug("Unhandled SAM event type: %s", event_type)
+            
+        message.call_acknowledgements()
+        
+    except Exception as e:
+        log.error("Error handling SAM event %s: %s", topic, e)
+        message.call_acknowledgements()
+
+
+
+async def cleanup_agent_session(component, session_id: str, user_id: str):
+    """Clean up agent-side session data."""
+    try:
+        log.info("Starting cleanup for session %s, user %s", session_id, user_id)
+        
+        if hasattr(component, 'session_service') and component.session_service:
+            agent_name = component.get_config("agent_name")
+            log.info("Deleting session %s from agent %s session service", session_id, agent_name)
+            await component.session_service.delete_session(
+                app_name=agent_name,
+                user_id=user_id,
+                session_id=session_id
+            )
+            log.info("Successfully deleted session %s from session service", session_id)
+        else:
+            log.info("No session service available for cleanup")
+            
+        with component.active_tasks_lock:
+            tasks_to_cancel = []
+            for task_id, context in component.active_tasks.items():
+                if (hasattr(context, 'a2a_context') and 
+                    context.a2a_context.get('session_id') == session_id):
+                    tasks_to_cancel.append(task_id)
+                    
+            for task_id in tasks_to_cancel:
+                context = component.active_tasks.get(task_id)
+                if context:
+                    context.cancel()
+                    log.info("Cancelled task %s for deleted session %s", task_id, session_id)
+        
+        log.info("Session cleanup completed for session %s", session_id)
+                    
+    except Exception as e:
+        log.error("Error cleaning up session %s: %s", session_id, e)

solace_agent_mesh/agent/sac/app.py

@@ -14,13 +14,13 @@ 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,
     get_discovery_topic,
     get_agent_response_subscription_topic,
     get_agent_status_subscription_topic,
+    get_sam_events_subscription_topic,
 )
 from ...common.constants import DEFAULT_COMMUNICATION_TIMEOUT
 from ...agent.sac.component import SamAgentComponent
@@ -680,6 +680,7 @@ class SamAgentApp(App):
             get_discovery_topic(namespace),
             get_agent_response_subscription_topic(namespace, agent_name),
             get_agent_status_subscription_topic(namespace, agent_name),
+            get_sam_events_subscription_topic(namespace, "session"),
         ]
         generated_subs = [{"topic": topic} for topic in required_topics]
         log.info(
@@ -714,4 +715,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