solace-agent-mesh 1.0.5__py3-none-any.whl → 1.0.7__py3-none-any.whl

solace_agent_mesh/agent/adk/services.py

@@ -27,7 +27,8 @@ from google.adk.memory import (
     VertexAiRagMemoryService,
 )
 
-from .filesystem_artifact_service import FilesystemArtifactService
+from .artifacts.filesystem_artifact_service import FilesystemArtifactService
+from .artifacts.s3_artifact_service import S3ArtifactService
 
 try:
     from sam_test_infrastructure.artifact_service.service import (
@@ -254,6 +255,39 @@ def initialize_artifact_service(component) -> BaseArtifactService:
                 e,
             )
             raise
+    elif service_type == "s3":
+        bucket_name = config.get("bucket_name")
+        if not bucket_name or not bucket_name.strip():
+            raise ValueError(
+                f"{component.log_identifier} 'bucket_name' is required and cannot be empty for S3 artifact service."
+            )
+
+        try:
+            s3_config = {}
+            
+            for key, value in config.items():
+                if key not in ["type", "bucket_name", "artifact_scope"]:
+                    s3_config[key] = value
+            
+            if "endpoint_url" not in s3_config:
+                s3_config["endpoint_url"] = "https://s3.amazonaws.com"
+                
+            aws_access_key_id = config.get("aws_access_key_id") or os.environ.get("AWS_ACCESS_KEY_ID")
+            aws_secret_access_key = config.get("aws_secret_access_key") or os.environ.get("AWS_SECRET_ACCESS_KEY")
+            
+            if aws_access_key_id:
+                s3_config["aws_access_key_id"] = aws_access_key_id
+            if aws_secret_access_key:
+                s3_config["aws_secret_access_key"] = aws_secret_access_key
+
+            concrete_service = S3ArtifactService(bucket_name=bucket_name, **s3_config)
+        except Exception as e:
+            log.error(
+                "%s Failed to initialize S3ArtifactService: %s",
+                component.log_identifier,
+                e,
+            )
+            raise
     elif service_type == "test_in_memory":
         if TestInMemoryArtifactService is None:
             log.error(

solace_agent_mesh/agent/adk/setup.py

@@ -10,6 +10,7 @@ from solace_ai_connector.common.utils import import_module
 
 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
@@ -18,7 +19,10 @@ 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
+from google.adk.tools.mcp_tool.mcp_session_manager import (
+    SseServerParams,
+    StdioConnectionParams,
+)
 
 from mcp import StdioServerParameters
 
@@ -55,11 +59,27 @@ async def load_adk_tools(
     loaded_tool_names: Set[str] = set()
     tools_config = component.get_config("tools", [])
 
+    def _check_and_register_tool_name(name: str, source: str):
+        """Checks for duplicate tool names and raises ValueError if found."""
+        if name in loaded_tool_names:
+            raise ValueError(
+                f"Configuration Error: Duplicate tool name '{name}' found from source '{source}'. "
+                "This name is already in use. Please resolve the conflict by renaming or "
+                "disabling one of the tools in your agent's configuration."
+            )
+        loaded_tool_names.add(name)
+
     if not tools_config:
         log.info(
             "%s No explicit tools configured in 'tools' list.", component.log_identifier
         )
     else:
+        log.debug(
+            "%s Processing %d tool configurations: %s",
+            component.log_identifier,
+            len(tools_config),
+            [tc.get("tool_type") for tc in tools_config],
+        )
         log.info(
             "%s Loading tools from 'tools' list configuration...",
             component.log_identifier,
@@ -91,6 +111,7 @@ async def load_adk_tools(
                         func,
                         specific_tool_config,
                         function_name,
+                        origin="python",
                         raw_string_args=tool_config.get("raw_string_args", []),
                     )
 
@@ -101,34 +122,23 @@ async def load_adk_tools(
                     if tool_description:
                         tool_callable.__doc__ = tool_description
 
-                    if function_name not in loaded_tool_names:
-                        loaded_tools.append(tool_callable)
-                        loaded_tool_names.add(function_name)
-                        log.info(
-                            "%s Loaded Python tool: %s from %s.",
-                            component.log_identifier,
-                            function_name,
-                            module_name,
-                        )
-                    else:
-                        log.debug(
-                            "%s Python tool '%s' already loaded. Skipping duplicate.",
-                            component.log_identifier,
-                            function_name,
-                        )
+                    _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,
+                    )
 
                 elif tool_type == "builtin":
                     tool_name = tool_config.get("tool_name")
                     if not tool_name:
                         raise ValueError("'tool_name' required for builtin tool.")
 
-                    if tool_name in loaded_tool_names:
-                        log.debug(
-                            "%s Tool '%s' already loaded. Skipping duplicate.",
-                            component.log_identifier,
-                            tool_name,
-                        )
-                        continue
+                    _check_and_register_tool_name(tool_name, "builtin")
 
                     sam_tool_def = tool_registry.get_tool_by_name(tool_name)
                     if sam_tool_def:
@@ -137,11 +147,11 @@ async def load_adk_tools(
                             sam_tool_def.implementation,
                             specific_tool_config,
                             sam_tool_def.name,
+                            origin="builtin",
                             raw_string_args=sam_tool_def.raw_string_args,
                         )
                         loaded_tools.append(tool_callable)
                         enabled_builtin_tools.append(sam_tool_def)
-                        loaded_tool_names.add(sam_tool_def.name)
                         log.info(
                             "%s Loaded SAM built-in tool: %s",
                             component.log_identifier,
@@ -151,8 +161,8 @@ async def load_adk_tools(
 
                     adk_tool = getattr(adk_tools_module, tool_name, None)
                     if adk_tool and isinstance(adk_tool, (BaseTool, Callable)):
+                        adk_tool.origin = "adk_builtin"
                         loaded_tools.append(adk_tool)
-                        loaded_tool_names.add(tool_name)
                         log.info(
                             "%s Loaded ADK built-in tool: %s",
                             component.log_identifier,
@@ -211,20 +221,22 @@ async def load_adk_tools(
 
                     group_tool_count = 0
                     for tool_def in tools_in_group:
-                        if tool_def.name not in loaded_tool_names:
-                            specific_tool_config = tool_config.get(
-                                "tool_configs", {}
-                            ).get(tool_def.name)
-                            tool_callable = ADKToolWrapper(
-                                tool_def.implementation,
-                                specific_tool_config,
-                                tool_def.name,
-                                raw_string_args=tool_def.raw_string_args,
-                            )
-                            loaded_tools.append(tool_callable)
-                            enabled_builtin_tools.append(tool_def)
-                            loaded_tool_names.add(tool_def.name)
-                            group_tool_count += 1
+                        _check_and_register_tool_name(
+                            tool_def.name, f"builtin-group:{group_name}"
+                        )
+                        specific_tool_config = tool_config.get("tool_configs", {}).get(
+                            tool_def.name
+                        )
+                        tool_callable = ADKToolWrapper(
+                            tool_def.implementation,
+                            specific_tool_config,
+                            tool_def.name,
+                            origin="builtin",
+                            raw_string_args=tool_def.raw_string_args,
+                        )
+                        loaded_tools.append(tool_callable)
+                        enabled_builtin_tools.append(tool_def)
+                        group_tool_count += 1
                     log.info(
                         "Loaded %d tools from built-in group: %s",
                         group_tool_count,
@@ -249,7 +261,6 @@ async def load_adk_tools(
                     }
                     connection_args["timeout"] = connection_args.get("timeout", 30)
 
-
                     environment_variables = tool_config.get("environment_variables")
                     env_param = {}
                     if connection_type == "stdio" and environment_variables:
@@ -292,9 +303,9 @@ async def load_adk_tools(
                                 **final_connection_args,
                                 env=env_param if env_param else None,
                             ),
-                            timeout=connection_args.get("timeout")
+                            timeout=connection_args.get("timeout"),
                         )
-                        
+
                     elif connection_type == "sse":
                         connection_params = SseServerParams(**connection_args)
                     else:
@@ -310,10 +321,37 @@ async def load_adk_tools(
                             tool_name,
                         )
 
-                    mcp_toolset_instance = MCPToolset(
+                    mcp_toolset_instance = EmbedResolvingMCPToolset(
                         connection_params=connection_params,
                         tool_filter=tool_filter_list,
+                        tool_config=tool_config,
                     )
+                    mcp_toolset_instance.origin = "mcp"
+
+                    # Check for duplicates from the MCP server
+                    try:
+                        mcp_tools = await mcp_toolset_instance.get_tools()
+                        log.debug(
+                            "%s Successfully discovered %d tools from MCP server: %s",
+                            component.log_identifier,
+                            len(mcp_tools),
+                            [tool.name for tool in mcp_tools],
+                        )
+                        for mcp_tool in mcp_tools:
+                            log.debug(
+                                "%s Registering MCP tool: %s",
+                                component.log_identifier,
+                                mcp_tool.name,
+                            )
+                            _check_and_register_tool_name(mcp_tool.name, "mcp")
+                    except Exception as e:
+                        log.error(
+                            "%s Failed to discover tools from MCP server: %s",
+                            component.log_identifier,
+                            str(e),
+                        )
+                        raise
+
                     loaded_tools.append(mcp_toolset_instance)
                     log.info(
                         "%s Initialized MCPToolset (filter: %s) for server: %s",
@@ -344,7 +382,9 @@ async def load_adk_tools(
         internal_tool_names.append("_continue_generation")
 
     for tool_name in internal_tool_names:
-        if tool_name in loaded_tool_names:
+        try:
+            _check_and_register_tool_name(tool_name, "internal")
+        except ValueError:
             log.debug(
                 "%s Internal tool '%s' was already loaded explicitly. Skipping implicit load.",
                 component.log_identifier,
@@ -359,13 +399,13 @@ async def load_adk_tools(
                 tool_def.implementation,
                 None,  # No specific config for internal tools
                 tool_def.name,
+                origin="internal",
             )
 
             tool_callable.__doc__ = tool_def.description
 
             loaded_tools.append(tool_callable)
             enabled_builtin_tools.append(tool_def)
-            loaded_tool_names.add(tool_def.name)
             log.info(
                 "%s Implicitly loaded internal framework tool: %s",
                 component.log_identifier,

solace_agent_mesh/agent/adk/tool_wrapper.py

@@ -13,6 +13,7 @@ from ...common.utils.embeds import (
     resolve_embeds_in_string,
     evaluate_embed,
     EARLY_EMBED_TYPES,
+    LATE_EMBED_TYPES,
     EMBED_DELIMITER_OPEN,
 )
 
@@ -31,15 +32,30 @@ class ADKToolWrapper:
         original_func: Callable,
         tool_config: Optional[Dict],
         tool_name: str,
+        origin: str,
         raw_string_args: Optional[List[str]] = None,
     ):
         self._original_func = original_func
         self._tool_config = tool_config or {}
         self._tool_name = tool_name
+        self.origin = origin
         self._raw_string_args = set(raw_string_args) if raw_string_args else set()
         self._is_async = inspect.iscoroutinefunction(original_func)
 
-        functools.update_wrapper(self, original_func)
+        # Ensure __name__ attribute is always set before functools.update_wrapper
+        self.__name__ = tool_name
+
+        try:
+            functools.update_wrapper(self, original_func)
+        except AttributeError as e:
+            log.debug(
+                "Could not fully update wrapper for tool '%s': %s. Using fallback attributes.",
+                self._tool_name,
+                e,
+            )
+            # Ensure essential attributes are set even if update_wrapper fails
+            self.__name__ = tool_name
+            self.__doc__ = getattr(original_func, "__doc__", None)
 
         try:
             self.__code__ = original_func.__code__
@@ -78,7 +94,7 @@ class ADKToolWrapper:
                         text=arg,
                         context=context_for_embeds,
                         resolver_func=evaluate_embed,
-                        types_to_resolve=EARLY_EMBED_TYPES,
+                        types_to_resolve=EARLY_EMBED_TYPES.union(LATE_EMBED_TYPES),
                         log_identifier=log_identifier,
                         config=self._tool_config,
                     )
@@ -99,7 +115,7 @@ class ADKToolWrapper:
                         text=value,
                         context=context_for_embeds,
                         resolver_func=evaluate_embed,
-                        types_to_resolve=EARLY_EMBED_TYPES,
+                        types_to_resolve=EARLY_EMBED_TYPES.union(LATE_EMBED_TYPES),
                         log_identifier=log_identifier,
                         config=self._tool_config,
                     )

solace_agent_mesh/agent/protocol/event_handlers.py

@@ -253,7 +253,7 @@ async def handle_a2a_request(component, message: SolaceMessage):
                     logical_task_id,
                 )
 
-                peer_sub_tasks = task_context.peer_sub_tasks
+                peer_sub_tasks = task_context.active_peer_sub_tasks
                 if peer_sub_tasks:
                     for sub_task_info in peer_sub_tasks:
                         sub_task_id = sub_task_info.get("sub_task_id")

solace_agent_mesh/agent/sac/app.py

@@ -302,6 +302,73 @@ class SamAgentApp(App):
                     },
                 },
             },
+            # --- MCP Intelligent Processing Config ---
+            {
+                "name": "mcp_intelligent_processing",
+                "required": False,
+                "type": "object",
+                "default": {},
+                "description": "Configuration for intelligent processing of MCP tool responses into typed artifacts.",
+                "properties": {
+                    "enable_intelligent_processing": {
+                        "type": "boolean",
+                        "required": False,
+                        "default": True,
+                        "description": "Enable intelligent content-aware processing of MCP responses. When disabled, falls back to raw JSON saving.",
+                    },
+                    "enable_text_format_detection": {
+                        "type": "boolean",
+                        "required": False,
+                        "default": True,
+                        "description": "Enable detection and parsing of structured text formats (CSV, JSON, YAML) within text content.",
+                    },
+                    "enable_content_parsing": {
+                        "type": "boolean",
+                        "required": False,
+                        "default": True,
+                        "description": "Enable parsing and validation of detected content formats for enhanced metadata.",
+                    },
+                    "fallback_to_raw_on_error": {
+                        "type": "boolean",
+                        "required": False,
+                        "default": True,
+                        "description": "Fall back to raw JSON saving if intelligent processing fails.",
+                    },
+                    "save_raw_alongside_intelligent": {
+                        "type": "boolean",
+                        "required": False,
+                        "default": False,
+                        "description": "Save both intelligent artifacts and raw JSON response for debugging/comparison.",
+                    },
+                    "max_content_items": {
+                        "type": "integer",
+                        "required": False,
+                        "default": 50,
+                        "description": "Maximum number of content items to process from a single MCP response.",
+                    },
+                    "max_single_item_size_mb": {
+                        "type": "integer",
+                        "required": False,
+                        "default": 100,
+                        "description": "Maximum size in MB for a single content item before skipping intelligent processing.",
+                    },
+                },
+            },
+            # --- MCP Tool Response Thresholds ---
+            {
+                "name": "mcp_tool_response_save_threshold_bytes",
+                "required": False,
+                "type": "integer",
+                "default": 2048,
+                "description": "Threshold in bytes above which MCP tool responses are saved as artifacts.",
+            },
+            {
+                "name": "mcp_tool_llm_return_max_bytes",
+                "required": False,
+                "type": "integer",
+                "default": 4096,
+                "description": "Maximum size in bytes of MCP tool response content returned directly to the LLM.",
+            },
             # --- Artifact Handling ---
             {
                 "name": "artifact_handling_mode",

solace_agent_mesh/agent/sac/component.py

@@ -1042,35 +1042,30 @@ class SamAgentComponent(ComponentBase):
 
             for func_decl in original_tool.function_declarations:
                 func_decl_name = func_decl.name
-                tool_source_for_log = "unknown"
-                tool_matched_for_capability_lookup = False
+                tool_object = llm_request.tools_dict.get(func_decl_name)
+                origin = getattr(tool_object, "origin", "unknown")
 
                 feature_descriptor = {
                     "feature_type": "tool_function",
                     "function_name": func_decl_name,
-                    "tool_source": self._determine_tool_source(func_decl_name),
-                    "tool_metadata": self._get_tool_metadata(func_decl_name),
+                    "tool_source": origin,
+                    "tool_metadata": {"function_name": func_decl_name},
                 }
 
-                if func_decl_name.startswith(PEER_TOOL_PREFIX):
+                if origin == "peer_agent":
                     peer_name = func_decl_name.replace(PEER_TOOL_PREFIX, "", 1)
                     feature_descriptor["tool_metadata"]["peer_agent_name"] = peer_name
-                    tool_source_for_log = f"PeerAgentTool ({peer_name})"
-                    tool_matched_for_capability_lookup = True
-
-                if not tool_matched_for_capability_lookup:
+                elif origin == "builtin":
                     tool_def = tool_registry.get_tool_by_name(func_decl_name)
                     if tool_def:
                         feature_descriptor["tool_metadata"][
                             "tool_category"
                         ] = tool_def.category
-                        feature_descriptor["tool_metadata"]["builtin_tool"] = True
-                        tool_source_for_log = (
-                            f"Built-in Tool ({tool_def.category}/{func_decl_name})"
-                        )
-                        tool_matched_for_capability_lookup = True
-
-                if not tool_matched_for_capability_lookup:
+                        feature_descriptor["tool_metadata"][
+                            "required_scopes"
+                        ] = tool_def.required_scopes
+                elif origin in ["python", "mcp", "adk_builtin"]:
+                    # Find the explicit config for this tool to pass to the resolver
                     for tool_cfg in explicit_tools_config:
                         cfg_tool_type = tool_cfg.get("tool_type")
                         cfg_tool_name = tool_cfg.get("tool_name")
@@ -1082,24 +1077,11 @@ class SamAgentComponent(ComponentBase):
                             cfg_tool_type in ["builtin", "mcp"]
                             and cfg_tool_name == func_decl_name
                         ):
-                            feature_descriptor["tool_metadata"][
-                                "tool_type"
-                            ] = cfg_tool_type
                             feature_descriptor["tool_metadata"][
                                 "tool_config"
                             ] = tool_cfg
-                            tool_source_for_log = f"Explicitly configured tool ({cfg_tool_type}: {cfg_tool_name or cfg_func_name})"
-                            tool_matched_for_capability_lookup = True
                             break
 
-                if not tool_matched_for_capability_lookup:
-                    log.debug(
-                        "%s FunctionDeclaration '%s' not found in any known configuration for capability checking. Assuming feature is available.",
-                        log_id_prefix,
-                        func_decl_name,
-                    )
-                    tool_source_for_log = "Unmatched/Implicit FunctionDeclaration"
-
                 context = {
                     "agent_context": self.get_agent_context(),
                     "filter_phase": "pre_llm",
@@ -1116,14 +1098,14 @@ class SamAgentComponent(ComponentBase):
                         "%s FunctionDeclaration '%s' (Source: %s) permitted.",
                         log_id_prefix,
                         func_decl_name,
-                        tool_source_for_log,
+                        origin,
                     )
                 else:
                     log.info(
                         "%s FunctionDeclaration '%s' (Source: %s) FILTERED OUT due to configuration restrictions.",
                         log_id_prefix,
                         func_decl_name,
-                        tool_source_for_log,
+                        origin,
                     )
 
             if permitted_declarations_for_this_tool:
@@ -1132,7 +1114,7 @@ class SamAgentComponent(ComponentBase):
 
                 final_filtered_genai_tools.append(scoped_tool)
                 log.debug(
-                    "%s Keeping genai.Tool (original name/type preserved, declarations filtered) as it has %d permitted FunctionDeclaration(s).",
+                    "%s Keeping genai.Tool as it has %d permitted FunctionDeclaration(s).",
                     log_id_prefix,
                     len(permitted_declarations_for_this_tool),
                 )
@@ -1169,60 +1151,6 @@ class SamAgentComponent(ComponentBase):
 
         return None
 
-    def _determine_tool_source(self, function_name: str) -> str:
-        """Determine the source/type of a tool function."""
-        if function_name.startswith("peer_"):
-            return "peer_agent"
-
-        tool_def = tool_registry.get_tool_by_name(function_name)
-        if tool_def:
-            category_map = {
-                "artifact_management": "builtin_artifact",
-                "data_analysis": "builtin_data",
-            }
-            return category_map.get(tool_def.category, "builtin_other")
-
-        return "explicit_tool"
-
-    def _get_tool_metadata(self, function_name: str) -> Dict[str, Any]:
-        """Get metadata for a tool function."""
-        metadata = {"function_name": function_name}
-
-        if function_name.startswith("peer_"):
-            peer_name = function_name.replace("peer_", "", 1)
-            metadata.update(
-                {"peer_agent_name": peer_name, "operation_type": "delegation"}
-            )
-            return metadata
-
-        tool_def = tool_registry.get_tool_by_name(function_name)
-        if tool_def:
-            metadata.update(
-                {
-                    "tool_category": tool_def.category,
-                    "required_scopes": tool_def.required_scopes,
-                    "builtin_tool": True,
-                }
-            )
-            return metadata
-
-        explicit_tools_config = self.get_config("tools", [])
-        for tool_cfg in explicit_tools_config:
-            cfg_tool_name = tool_cfg.get("tool_name")
-            cfg_func_name = tool_cfg.get("function_name")
-            if (
-                tool_cfg.get("tool_type") == "python" and cfg_func_name == function_name
-            ) or (
-                tool_cfg.get("tool_type") in ["builtin", "mcp"]
-                and cfg_tool_name == function_name
-            ):
-                metadata.update(
-                    {"tool_type": tool_cfg.get("tool_type"), "tool_config": tool_cfg}
-                )
-                break
-
-        return metadata
-
     def get_agent_context(self) -> Dict[str, Any]:
         """Get agent context for middleware calls."""
         return {