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

solace_agent_mesh/agent/adk/runner.py

@@ -201,13 +201,13 @@ async def run_adk_async_task_thread_wrapper(
             llm_limit_e,
         )
     except BadRequestError as e:
+        exception_to_finalize_with = e
         log.error(
-            "%s Bad Request for task %s: %s.",
+            "%s Bad Request for task %s: %s. Scheduling finalization.",
             component.log_identifier,
             logical_task_id,
             e.message,
         )
-        raise
     except Exception as e:
         exception_to_finalize_with = e
         log.exception(
@@ -261,7 +261,11 @@ async def run_adk_async_task(
     logical_task_id = a2a_context.get("logical_task_id", "unknown_task")
     event_loop_stored = False
     current_loop = asyncio.get_running_loop()
-    is_paused = False
+    # Track pending long-running tools by their function_call IDs
+    # This replaces the simple boolean is_paused to properly handle sync returns
+    pending_long_running_tools: set[str] = set()
+    # Collect synchronous responses from long-running tools for potential re-run
+    sync_tool_responses: list[adk_types.Part] = []
 
     adk_event_generator = component.runner.run_async(
         user_id=adk_session.user_id,
@@ -316,7 +320,10 @@ async def run_adk_async_task(
                 break
 
             if event.long_running_tool_ids:
-                is_paused = True
+                # Track which long-running tool calls are pending (waiting for async response)
+                pending_long_running_tools = pending_long_running_tools.union(
+                    event.long_running_tool_ids
+                )
 
             if not event_loop_stored and event.invocation_id:
                 task_context.set_event_loop(current_loop)
@@ -342,8 +349,18 @@ async def run_adk_async_task(
             if event.content and event.content.parts:
                 for part in event.content.parts:
                     if part.function_response:
-                        if part.function_response.name.startswith("peer_"):
-                            pass
+                        # Check if this is a sync response from a long-running tool
+                        # (i.e., the tool returned immediately instead of async)
+                        response_id = part.function_response.id
+                        if response_id and response_id in pending_long_running_tools:
+                            pending_long_running_tools.discard(response_id)
+                            sync_tool_responses.append(part)
+                            log.info(
+                                "%s Long-running tool %s (id=%s) returned synchronously.",
+                                component.log_identifier,
+                                part.function_response.name,
+                                response_id,
+                            )
 
     except TaskCancelledError:
         raise
@@ -374,14 +391,55 @@ async def run_adk_async_task(
             f"Task {logical_task_id} was cancelled before finalization."
         )
 
-    if is_paused:
+    invocation_id = a2a_context.get("invocation_id")
+
+    # Check if we still have pending long-running tools (waiting for async responses)
+    if pending_long_running_tools:
+        # Store any sync responses using the SAME format as event_handlers.py
+        # This ensures they're combined with async responses when _retrigger is called
+        if sync_tool_responses:
+            for part in sync_tool_responses:
+                result = {
+                    "adk_function_call_id": part.function_response.id,
+                    "peer_tool_name": part.function_response.name,
+                    "payload": part.function_response.response,  # Already a dict from ADK
+                }
+                task_context.record_parallel_result(result, invocation_id)
+            log.info(
+                "%s Stored %d sync tool response(s) for later combination. Waiting for: %s",
+                component.log_identifier,
+                len(sync_tool_responses),
+                pending_long_running_tools,
+            )
+
         log.info(
-            "%s ADK run completed by invoking a long-running tool. Task %s will remain open, awaiting peer response.",
+            "%s Task %s paused, waiting for %d async tool response(s).",
             component.log_identifier,
             logical_task_id,
+            len(pending_long_running_tools),
         )
         return True
 
+    # All tools returned synchronously - re-run ADK with their responses
+    # The ADK already created the Part objects, so we use them directly (no duplication)
+    if sync_tool_responses:
+        log.info(
+            "%s All %d long-running tool(s) returned synchronously for task %s. Re-running ADK.",
+            component.log_identifier,
+            len(sync_tool_responses),
+            logical_task_id,
+        )
+        # Use the Part objects directly from the ADK (already properly formatted)
+        tool_response_content = adk_types.Content(role="tool", parts=sync_tool_responses)
+        return await run_adk_async_task(
+            component=component,
+            task_context=task_context,
+            adk_session=adk_session,
+            adk_content=tool_response_content,
+            run_config=run_config,
+            a2a_context=a2a_context,
+        )
+
     log.debug(
         "%s ADK run_async completed for task %s. Returning to wrapper for finalization.",
         component.log_identifier,

solace_agent_mesh/agent/adk/schema_migration.py

@@ -0,0 +1,88 @@
+"""
+ADK Database Schema Migrations
+
+Automatically runs Alembic migrations on agent startup to ensure
+database schema compatibility with the installed ADK version.
+
+This uses Google ADK's official migration approach via Alembic's
+autogenerate feature to detect and apply schema changes.
+"""
+
+import logging
+import re
+from pathlib import Path
+from alembic.config import Config
+from alembic import command
+
+log = logging.getLogger(__name__)
+
+
+def run_migrations(db_service, component):
+    """
+    Run Alembic database migrations programmatically.
+
+    Executes any pending migrations to ensure the database schema
+    matches ADK's model definitions. This is equivalent to running:
+        alembic upgrade head
+
+    Args:
+        db_service: DatabaseSessionService instance
+        component: Component that owns this service (for logging)
+
+    Raises:
+        RuntimeError: If migration fails
+    """
+
+    try:
+        # Get paths to alembic directory and config
+        module_dir = Path(__file__).parent
+        alembic_ini = module_dir / "alembic.ini"
+        alembic_dir = module_dir / "alembic"
+
+        # Verify files exist
+        if not alembic_ini.exists():
+            log.warning(
+                "%s alembic.ini not found at %s, skipping migration",
+                component.log_identifier,
+                alembic_ini
+            )
+            return
+
+        if not alembic_dir.exists():
+            log.warning(
+                "%s alembic/ directory not found at %s, skipping migration",
+                component.log_identifier,
+                alembic_dir
+            )
+            return
+
+        # Create Alembic config
+        alembic_cfg = Config(str(alembic_ini))
+        alembic_cfg.set_main_option("script_location", str(alembic_dir))
+        
+        # IMPORTANT: Store the engine in config attributes so env.py can access it
+        # This avoids URL encoding issues entirely
+        alembic_cfg.attributes['connection'] = db_service.db_engine
+
+        log.info(
+            "%s Running Alembic migrations for ADK schema compatibility...",
+            component.log_identifier
+        )
+
+        # Run migrations (equivalent to: alembic upgrade head)
+        # Run migrations (env.py will use the engine from attributes)
+        command.upgrade(alembic_cfg, "head")
+
+        log.info(
+            "%s Database schema migration complete",
+            component.log_identifier
+        )
+
+    except Exception as e:
+        log.error(
+            "%s Database migration failed: %s",
+            component.log_identifier,
+            e
+        )
+        raise RuntimeError(f"ADK database migration failed: {e}") from e
+    

solace_agent_mesh/agent/adk/services.py

@@ -12,6 +12,7 @@ from google.adk.artifacts import (
     GcsArtifactService,
     InMemoryArtifactService,
 )
+from google.adk.artifacts.base_artifact_service import ArtifactVersion
 from google.adk.auth.credential_service.base_credential_service import (
     BaseCredentialService,
 )
@@ -33,6 +34,7 @@ from google.genai import types as adk_types
 from typing_extensions import override
 
 from .artifacts.filesystem_artifact_service import FilesystemArtifactService
+from .schema_migration import run_migrations
 
 log = logging.getLogger(__name__)
 
@@ -156,6 +158,42 @@ class ScopedArtifactServiceWrapper(BaseArtifactService):
             filename=filename,
         )
 
+    @override
+    async def list_artifact_versions(
+        self,
+        *,
+        app_name: str,
+        user_id: str,
+        filename: str,
+        session_id: str,
+    ) -> List[ArtifactVersion]:
+        scoped_app_name = self._get_scoped_app_name(app_name)
+        return await self.wrapped_service.list_artifact_versions(
+            app_name=scoped_app_name,
+            user_id=user_id,
+            filename=filename,
+            session_id=session_id,
+        )
+
+    @override
+    async def get_artifact_version(
+        self,
+        *,
+        app_name: str,
+        user_id: str,
+        filename: str,
+        session_id: str,
+        version: Optional[int] = None,
+    ) -> Optional[ArtifactVersion]:
+        scoped_app_name = self._get_scoped_app_name(app_name)
+        return await self.wrapped_service.get_artifact_version(
+            app_name=scoped_app_name,
+            user_id=user_id,
+            filename=filename,
+            session_id=session_id,
+            version=version,
+        )
+
 
 def _sanitize_for_path(identifier: str) -> str:
     """Sanitizes a string to be safe for use as a directory name."""
@@ -195,7 +233,9 @@ def initialize_session_service(component) -> BaseSessionService:
                 f"{component.log_identifier} 'database_url' is required for sql session service."
             )
         try:
-            return DatabaseSessionService(db_url=db_url)
+            db_service = DatabaseSessionService(db_url=db_url)
+            run_migrations(db_service, component)
+            return db_service
         except ImportError:
             log.error(
                 "%s SQLAlchemy not installed. Please install 'google-adk[database]' or 'sqlalchemy'.",

solace_agent_mesh/agent/adk/setup.py

@@ -5,7 +5,19 @@ Handles ADK Agent and Runner initialization, including tool loading and callback
 import functools
 import inspect
 import logging
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Set, Tuple, Type, Union
+import os
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    Union,
+)
 
 from google.adk import tools as adk_tools_module
 from google.adk.agents.callback_context import CallbackContext
@@ -14,6 +26,7 @@ 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,
@@ -29,8 +42,8 @@ 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,
 )
@@ -483,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,
@@ -501,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
@@ -548,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()
@@ -570,14 +646,30 @@ 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,
         )
 
     additional_params = {}
@@ -592,7 +684,7 @@ async def _load_mcp_tool(component: "SamAgentComponent", tool_config: Dict) -> T
                 tool_type="mcp",
                 tool_config=tool_config,
                 connection_params=connection_params,
-                tool_filter=tool_filter_list,
+                tool_filter=tool_filter,
             )
         except Exception as e:
             log.error(
@@ -609,7 +701,8 @@ async def _load_mcp_tool(component: "SamAgentComponent", tool_config: Dict) -> T
     # Create the EmbedResolvingMCPToolset with base parameters
     toolset_params = {
         "connection_params": connection_params,
-        "tool_filter": tool_filter_list,
+        "tool_filter": tool_filter,
+        "tool_name_prefix": tool_config_model.tool_name_prefix,
         "tool_config": tool_config,
     }
 
@@ -620,14 +713,86 @@ async def _load_mcp_tool(component: "SamAgentComponent", tool_config: Dict) -> T
     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]] = []
@@ -749,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",
@@ -761,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)
@@ -817,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]],
@@ -1089,7 +1267,17 @@ 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
         )
@@ -1099,7 +1287,7 @@ def initialize_adk_agent(
             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
         )
@@ -1109,13 +1297,13 @@ def initialize_adk_agent(
             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
         )
@@ -1190,4 +1378,4 @@ def initialize_adk_runner(component) -> Runner:
         return runner
     except Exception as e:
         log.error("%s Failed to create ADK Runner: %s", component.log_identifier, e)
-        raise
+        raise