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

solace_agent_mesh/agent/adk/embed_resolving_mcp_toolset.py

@@ -1,45 +1,176 @@
 """
 Custom MCPToolset that resolves embeds in tool parameters before calling MCP tools.
+
+This module uses dynamic inheritance to support both standard and enterprise MCP tools:
+- Standard mode: Inherits from MCPTool and MCPToolset (Google ADK)
+- Enterprise mode: Inherits from McpToolWithManifest and McpToolsetWithManifest
+  (adds manifest support and tool_config parameter)
+
+The base class is determined at import time based on enterprise package availability.
 """
 
 import logging
-import asyncio
-from typing import Dict, List, Optional, Any
-
-from google.adk.tools.mcp_tool import MCPToolset, MCPTool
-from google.adk.tools.mcp_tool.mcp_session_manager import (
-    SseConnectionParams,
-    StdioConnectionParams,
-    StreamableHTTPConnectionParams,
-)
-from google.adk.tools.tool_context import ToolContext
+import time
+from typing import Any
 
+from google.adk.auth.credential_manager import CredentialManager
+from google.adk.tools.mcp_tool import MCPTool, MCPToolset
+from google.adk.tools.tool_context import ToolContext
 
-from ..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,
+    LATE_EMBED_TYPES,
+    evaluate_embed,
+    resolve_embeds_in_string,
 )
+from ...common.utils.embeds.types import ResolutionMode
+from ..utils.context_helpers import get_original_session_id
 
 log = logging.getLogger(__name__)
 
-class EmbedResolvingMCPTool(MCPTool):
+
+def _get_base_mcp_toolset_class() -> tuple[type[MCPToolset], bool]:
+    """
+    Factory function to determine which base MCP toolset class to use for inheritance.
+
+    Tries to import McpToolsetWithManifest from solace_agent_mesh_enterprise.common
+    and returns it if available. Falls back to base MCPToolset if not available.
+
+    Returns:
+        Tuple of (class, supports_tool_config_flag) where:
+        - class: The base MCPToolset class to inherit from
+        - supports_tool_config_flag: Whether the class supports tool_config parameter
+    """
+    try:
+        from solace_agent_mesh_enterprise.auth.mcp_toolset_with_manifest import (
+            McpToolsetWithManifest,
+        )
+
+        return (McpToolsetWithManifest, True)
+    except ImportError:
+        return (MCPToolset, False)
+
+
+def _get_base_mcp_tool_class() -> tuple[type[MCPTool], bool]:
+    """
+    Factory function to determine which base MCP tool class to use for inheritance.
+
+    Tries to import McpToolWithManifest from solace_agent_mesh_enterprise.common
+    and returns it if available. Falls back to base MCPTool if not available.
+
+    Returns:
+        Tuple of (class, supports_tool_config_flag) where:
+        - class: The base MCPTool class to inherit from
+        - supports_tool_config_flag: Whether the class supports tool_config parameter
+    """
+    try:
+        from solace_agent_mesh_enterprise.auth.mcp_toolset_with_manifest import (
+            McpToolWithManifest,
+        )
+
+        return (McpToolWithManifest, True)
+    except ImportError:
+        return (MCPTool, False)
+
+
+# Get the base tool class to use for inheritance
+_BaseMcpToolClass, _base_supports_tool_config = _get_base_mcp_tool_class()
+
+
+def _log_mcp_tool_call(userId, agentId, tool_name, session_id):
+    """A short log message so that customers can track tool usage per user/agent"""
+    log.info(
+        "MCP Tool Call - UserID: %s, AgentID: %s, ToolName: %s, SessionID: %s",
+        userId,
+        agentId,
+        tool_name,
+        session_id,
+        extra={
+            "user_id": userId,
+            "agent_id": agentId,
+            "tool_name": tool_name,
+            "session_id": session_id,
+        },
+    )
+
+
+def _log_mcp_tool_success(userId, agentId, tool_name, session_id, duration_ms):
+    """A short log message so that customers can track successful tool completion per user/agent"""
+    log.info(
+        "MCP Tool Success - UserID: %s, AgentID: %s, ToolName: %s, SessionID: %s, Duration: %.2fms",
+        userId,
+        agentId,
+        tool_name,
+        session_id,
+        duration_ms,
+        extra={
+            "user_id": userId,
+            "agent_id": agentId,
+            "tool_name": tool_name,
+            "session_id": session_id,
+            "duration_ms": duration_ms,
+        },
+    )
+
+
+def _log_mcp_tool_failure(userId, agentId, tool_name, session_id, duration_ms, error):
+    """A short log message so that customers can track tool failures per user/agent"""
+    log.error(
+        "MCP Tool Failure - UserID: %s, AgentID: %s, ToolName: %s, SessionID: %s, Duration: %.2fms, Error: %s",
+        userId,
+        agentId,
+        tool_name,
+        session_id,
+        duration_ms,
+        str(error),
+        extra={
+            "user_id": userId,
+            "agent_id": agentId,
+            "tool_name": tool_name,
+            "session_id": session_id,
+            "duration_ms": duration_ms,
+        },
+    )
+
+
+class EmbedResolvingMCPTool(_BaseMcpToolClass):
     """
     Custom MCPTool that resolves embeds in parameters before calling the actual MCP tool.
+    Uses dynamic inheritance to conditionally inherit from McpToolWithManifest when available,
+    falling back to the standard MCPTool base class.
     """
 
-    def __init__(self, original_mcp_tool: MCPTool, tool_config: Optional[Dict] = None):
+    def __init__(
+        self,
+        original_mcp_tool: MCPTool,
+        tool_config: dict | None = None,
+        credential_manager: CredentialManager | None = None,
+    ):
         # Copy all attributes from the original tool
-        super().__init__(
-            mcp_tool=original_mcp_tool._mcp_tool,
-            mcp_session_manager=original_mcp_tool._mcp_session_manager,
-            auth_scheme=getattr(original_mcp_tool, "_auth_scheme", None),
-            auth_credential=getattr(original_mcp_tool, "_auth_credential", None),
-        )
-        self._original_mcp_tool = original_mcp_tool
+        if _base_supports_tool_config:
+            super().__init__(
+                mcp_tool=original_mcp_tool._mcp_tool,
+                mcp_session_manager=original_mcp_tool._mcp_session_manager,
+                auth_scheme=getattr(original_mcp_tool._mcp_tool, "auth_scheme", None),
+                auth_credential=getattr(
+                    original_mcp_tool._mcp_tool, "auth_credential", None
+                ),
+                auth_discovery=getattr(
+                    original_mcp_tool._mcp_tool, "auth_discovery", None
+                ),
+                credential_manager=credential_manager,
+            )
+        else:
+            super().__init__(
+                mcp_tool=original_mcp_tool._mcp_tool,
+                mcp_session_manager=original_mcp_tool._mcp_session_manager,
+                auth_scheme=getattr(original_mcp_tool._mcp_tool, "auth_scheme", None),
+                auth_credential=getattr(
+                    original_mcp_tool._mcp_tool, "auth_credential", None
+                ),
+            )
+        self._original_mcp_tool: MCPTool = original_mcp_tool
         self._tool_config = tool_config or {}
 
     async def _resolve_embeds_recursively(
@@ -112,6 +243,7 @@ class EmbedResolvingMCPTool(MCPTool):
                         context=resolution_context,
                         resolver_func=evaluate_embed,
                         types_to_resolve=EARLY_EMBED_TYPES.union(LATE_EMBED_TYPES),
+                        resolution_mode=ResolutionMode.TOOL_PARAMETER,
                         log_identifier=log_identifier,
                         config=self._tool_config,
                     )
@@ -201,6 +333,38 @@ class EmbedResolvingMCPTool(MCPTool):
         )
         return data
 
+
+    async def _execute_tool_with_audit_logs(self, tool_call, tool_context):
+        _log_mcp_tool_call(
+            tool_context.session.user_id,
+            tool_context.agent_name,
+            self.name,
+            tool_context.session.id,
+        )
+        start_time = time.perf_counter()
+        try:
+            result = await tool_call()
+            duration_ms = (time.perf_counter() - start_time) * 1000
+            _log_mcp_tool_success(
+                tool_context.session.user_id,
+                tool_context.agent_name,
+                self.name,
+                tool_context.session.id,
+                duration_ms,
+            )
+            return result
+        except Exception as e:
+            duration_ms = (time.perf_counter() - start_time) * 1000
+            _log_mcp_tool_failure(
+                tool_context.session.user_id,
+                tool_context.agent_name,
+                self.name,
+                tool_context.session.id,
+                duration_ms,
+                e,
+            )
+            raise
+
     async def _run_async_impl(
         self, *, args, tool_context: ToolContext, credential
     ) -> Any:
@@ -211,7 +375,6 @@ class EmbedResolvingMCPTool(MCPTool):
 
         # Get context for embed resolution - pass the tool_context object directly
         context_for_embeds = tool_context
-
         if context_for_embeds:
             log.debug(
                 "%s Starting recursive embed resolution for all parameters. Context type: %s",
@@ -247,38 +410,71 @@ class EmbedResolvingMCPTool(MCPTool):
                 log_identifier,
             )
             resolved_args = args
-
         # Call the original MCP tool with resolved parameters
-        return await self._original_mcp_tool._run_async_impl(
-            args=resolved_args, tool_context=tool_context, credential=credential
+        return await self._execute_tool_with_audit_logs(
+            lambda: self._original_mcp_tool._run_async_impl(
+                args=resolved_args, tool_context=tool_context, credential=credential
+            ),
+            tool_context,
         )
 
+# Get the base toolset class to use for inheritance
+_BaseMcpToolsetClass, _base_toolset_supports_tool_config = _get_base_mcp_toolset_class()
 
-class EmbedResolvingMCPToolset(MCPToolset):
+
+class EmbedResolvingMCPToolset(_BaseMcpToolsetClass):
     """
     Custom MCPToolset that creates EmbedResolvingMCPTool instances for embed resolution.
+    Uses dynamic inheritance to conditionally inherit from McpToolsetWithManifest when available,
+    falling back to the standard MCPToolset base class.
     """
 
     def __init__(
         self,
         connection_params,
         tool_filter=None,
+        tool_name_prefix=None,
         auth_scheme=None,
         auth_credential=None,
-        tool_config: Optional[Dict] = None,
+        auth_discovery=None,
+        tool_config: dict | None = None,
+        credential_manager: CredentialManager | None = None,
     ):
-        super().__init__(
-            connection_params=connection_params,
-            tool_filter=tool_filter,
-            auth_scheme=auth_scheme,
-            auth_credential=auth_credential,
-        )
+        # Store tool_config for later use
         self._tool_config = tool_config or {}
 
-    async def get_tools(self, readonly_context=None) -> List[MCPTool]:
+        # Initialize base class with appropriate parameters
+        if _base_toolset_supports_tool_config:
+            super().__init__(
+                connection_params=connection_params,
+                tool_filter=tool_filter,
+                tool_name_prefix=tool_name_prefix,
+                auth_scheme=auth_scheme,
+                auth_credential=auth_credential,
+                auth_discovery=auth_discovery,
+                tool_config=tool_config,
+            )
+        else:
+            # Base MCPToolset doesn't support tool_config parameter
+            super().__init__(
+                connection_params=connection_params,
+                tool_filter=tool_filter,
+                tool_name_prefix=tool_name_prefix,
+                auth_scheme=auth_scheme,
+                auth_credential=auth_credential,
+            )
+
+        self._tool_cache = []
+        self._credential_manager = credential_manager
+
+    async def get_tools(self, readonly_context=None) -> list[MCPTool]:
         """
         Override get_tools to return EmbedResolvingMCPTool instances.
         """
+
+        if self._tool_cache:
+            return self._tool_cache
+
         # Get the original tools from the parent class
         original_tools = await super().get_tools(readonly_context)
 
@@ -294,7 +490,9 @@ class EmbedResolvingMCPToolset(MCPToolset):
             embed_resolving_tool = EmbedResolvingMCPTool(
                 original_mcp_tool=tool,
                 tool_config=tool_specific_config,
+                credential_manager=self._credential_manager,
             )
             embed_resolving_tools.append(embed_resolving_tool)
 
+        self._tool_cache = embed_resolving_tools
         return embed_resolving_tools

solace_agent_mesh/agent/adk/intelligent_mcp_callbacks.py

@@ -19,6 +19,7 @@ from .mcp_content_processor import MCPContentProcessor, MCPContentProcessorConfi
 from ...agent.utils.artifact_helpers import (
     save_artifact_with_metadata,
     DEFAULT_SCHEMA_MAX_KEYS,
+    DEFAULT_SCHEMA_INFERENCE_DEPTH,
 )
 from ...agent.utils.context_helpers import get_original_session_id
 
@@ -28,6 +29,41 @@ if TYPE_CHECKING:
     from ...agent.sac.component import SamAgentComponent
 
 
+def _get_schema_config_from_tool_or_agent(
+    tool: BaseTool,
+    host_component: "SamAgentComponent",
+    config_key: str,
+    default_value: Any,
+) -> Any:
+    """
+    Get schema configuration from tool_config if available, otherwise fall back to agent config.
+
+    This allows per-tool override of schema settings like schema_inference_depth.
+
+    Args:
+        tool: The MCP tool instance (may have _tool_config attribute)
+        host_component: The agent component for fallback config
+        config_key: The configuration key to look up
+        default_value: Default value if not found in either location
+
+    Returns:
+        The configuration value from tool config, agent config, or default
+    """
+    # Check if tool has tool_config with this setting
+    tool_config = getattr(tool, "_tool_config", None)
+    if tool_config and isinstance(tool_config, dict):
+        if config_key in tool_config:
+            log.debug(
+                "Using per-tool config for %s: %s",
+                config_key,
+                tool_config[config_key],
+            )
+            return tool_config[config_key]
+
+    # Fall back to agent-level config
+    return host_component.get_config(config_key, default_value)
+
+
 class McpSaveStatus(str, Enum):
     """Enumeration for the status of an MCP save operation."""
 
@@ -164,7 +200,7 @@ async def save_mcp_response_as_artifact_intelligent(
                 if hasattr(item, "uri"):
                     item.uri = str(item.uri)
                 result_dict = await _save_content_item_as_artifact(
-                    item, tool_context, host_component
+                    item, tool, tool_context, host_component
                 )
                 if result_dict.get("status") in ["success", "partial_success"]:
                     saved_artifacts.append(SavedArtifactInfo(**result_dict))
@@ -279,6 +315,7 @@ async def save_mcp_response_as_artifact_intelligent(
 
 async def _save_content_item_as_artifact(
     content_item,
+    tool: BaseTool,
     tool_context: ToolContext,
     host_component: "SamAgentComponent",
 ) -> Dict[str, Any]:
@@ -294,8 +331,12 @@ async def _save_content_item_as_artifact(
         app_name = host_component.agent_name
         user_id = tool_context._invocation_context.user_id
         session_id = get_original_session_id(tool_context._invocation_context)
-        schema_max_keys = host_component.get_config(
-            "schema_max_keys", DEFAULT_SCHEMA_MAX_KEYS
+        # Get schema config from tool_config (per-tool) or agent config (fallback)
+        schema_max_keys = _get_schema_config_from_tool_or_agent(
+            tool, host_component, "schema_max_keys", DEFAULT_SCHEMA_MAX_KEYS
+        )
+        schema_inference_depth = _get_schema_config_from_tool_or_agent(
+            tool, host_component, "schema_inference_depth", DEFAULT_SCHEMA_INFERENCE_DEPTH
         )
         artifact_timestamp = datetime.now(timezone.utc)
 
@@ -318,6 +359,7 @@ async def _save_content_item_as_artifact(
             metadata_dict=content_item.metadata,
             timestamp=artifact_timestamp,
             schema_max_keys=schema_max_keys,
+            schema_inference_depth=schema_inference_depth,
             tool_context=tool_context,
         )
 
@@ -376,8 +418,12 @@ async def _save_raw_mcp_response_fallback(
         app_name = host_component.agent_name
         user_id = tool_context._invocation_context.user_id
         session_id = get_original_session_id(tool_context._invocation_context)
-        schema_max_keys = host_component.get_config(
-            "schema_max_keys", DEFAULT_SCHEMA_MAX_KEYS
+        # Get schema config from tool_config (per-tool) or agent config (fallback)
+        schema_max_keys = _get_schema_config_from_tool_or_agent(
+            tool, host_component, "schema_max_keys", DEFAULT_SCHEMA_MAX_KEYS
+        )
+        schema_inference_depth = _get_schema_config_from_tool_or_agent(
+            tool, host_component, "schema_inference_depth", DEFAULT_SCHEMA_INFERENCE_DEPTH
         )
 
         save_result = await save_artifact_with_metadata(
@@ -391,6 +437,7 @@ async def _save_raw_mcp_response_fallback(
             metadata_dict=metadata_for_saving,
             timestamp=artifact_timestamp,
             schema_max_keys=schema_max_keys,
+            schema_inference_depth=schema_inference_depth,
             tool_context=tool_context,
         )
 

solace_agent_mesh/agent/adk/mcp_content_processor.py

@@ -540,7 +540,7 @@ class MCPContentProcessor:
 
         format_mapping = {
             TextFormat.JSON: ("application/json", ".json"),
-            TextFormat.YAML: ("application/x-yaml", ".yaml"),
+            TextFormat.YAML: ("application/yaml", ".yaml"),
             TextFormat.CSV: ("text/csv", ".csv"),
             TextFormat.MARKDOWN: ("text/markdown", ".md"),
             TextFormat.PLAIN: ("text/plain", ".txt"),

solace_agent_mesh/agent/adk/models/lite_llm.py

@@ -15,6 +15,7 @@
 from __future__ import annotations
 
 import base64
+import hashlib
 import json
 import logging
 from typing import Any
@@ -144,6 +145,38 @@ def _safe_json_serialize(obj) -> str:
         return str(obj)
 
 
+def _truncate_tool_call_id(tool_call_id: str, max_length: int = 40) -> str:
+    """Truncates tool call ID to meet OpenAI's maximum length requirement.
+    
+    OpenAI requires tool_call_id to be at most 40 characters. If the ID exceeds
+    this limit, we create a deterministic hash-based truncation to ensure:
+    1. The ID stays within the limit
+    2. The same input always produces the same output (deterministic)
+    3. Collisions are extremely unlikely
+    
+    Args:
+        tool_call_id: The original tool call ID
+        max_length: Maximum allowed length (default: 40 for OpenAI)
+    
+    Returns:
+        Truncated tool call ID that meets the length requirement
+    """
+    if len(tool_call_id) <= max_length:
+        return tool_call_id
+    
+    # Use first part of ID + hash of full ID to maintain uniqueness
+    # Format: prefix_hash where prefix is from original and hash ensures uniqueness
+    prefix_length = max_length - 33  # Reserve 33 chars for hash (32) + underscore (1)
+    if prefix_length < 1:
+        prefix_length = 1
+    
+    prefix = tool_call_id[:prefix_length]
+    # Use SHA256 and take first 32 hex characters for uniqueness
+    hash_suffix = hashlib.sha256(tool_call_id.encode()).hexdigest()[:32]
+    
+    return f"{prefix}_{hash_suffix}"
+
+
 def _content_to_message_param(
     content: types.Content,
 ) -> Union[Message, list[Message]]:
@@ -165,7 +198,7 @@ def _content_to_message_param(
             tool_messages.append(
                 ChatCompletionToolMessage(
                     role="tool",
-                    tool_call_id=part.function_response.id,
+                    tool_call_id=_truncate_tool_call_id(part.function_response.id),
                     content=_safe_json_serialize(part.function_response.response),
                 )
             )
@@ -185,7 +218,7 @@ def _content_to_message_param(
                 tool_calls.append(
                     ChatCompletionAssistantToolCall(
                         type="function",
-                        id=part.function_call.id,
+                        id=_truncate_tool_call_id(part.function_call.id),
                         function=Function(
                             name=part.function_call.name,
                             arguments=_safe_json_serialize(part.function_call.args),
@@ -295,26 +328,41 @@ def _schema_to_dict(schema: types.Schema) -> dict:
     """
 
     schema_dict = schema.model_dump(exclude_none=True)
+
+    # Convert top-level type from enum to lowercase string
     if "type" in schema_dict:
-        schema_dict["type"] = schema_dict["type"].lower()
+        if isinstance(schema_dict["type"], types.Type):
+            schema_dict["type"] = schema_dict["type"].value.lower()
+        else:
+            schema_dict["type"] = str(schema_dict["type"]).lower()
+
+    # Recursively handle items (for array types)
     if "items" in schema_dict:
-        if isinstance(schema_dict["items"], dict):
+        # Check if we have the original Schema object for items
+        if isinstance(schema.items, types.Schema):
+            # Recursively convert the Schema object - this ensures nested Type enums are converted
+            schema_dict["items"] = _schema_to_dict(schema.items)
+        elif isinstance(schema_dict["items"], dict):
+            # If items is already a dict, validate and recurse
             schema_dict["items"] = _schema_to_dict(
                 types.Schema.model_validate(schema_dict["items"])
             )
-        elif isinstance(schema_dict["items"]["type"], types.Type):
-            schema_dict["items"]["type"] = TYPE_LABELS[
-                schema_dict["items"]["type"].value
-            ]
+
+    # Recursively handle properties (for object types)
     if "properties" in schema_dict:
         properties = {}
         for key, value in schema_dict["properties"].items():
             if isinstance(value, types.Schema):
+                # If it's a Schema object, recursively convert it
                 properties[key] = _schema_to_dict(value)
+            elif isinstance(value, dict):
+                # If it's already a dict, validate and recurse to handle nested Type enums
+                properties[key] = _schema_to_dict(
+                    types.Schema.model_validate(value)
+                )
             else:
+                # For other types, just copy as-is
                 properties[key] = value
-                if "type" in properties[key]:
-                    properties[key]["type"] = properties[key]["type"].lower()
         schema_dict["properties"] = properties
     return schema_dict
 
@@ -333,20 +381,23 @@ def _function_declaration_to_tool_param(
 
     assert function_declaration.name
 
-    properties = {}
-    if function_declaration.parameters and function_declaration.parameters.properties:
-        for key, value in function_declaration.parameters.properties.items():
-            properties[key] = _schema_to_dict(value)
+    # Convert the entire parameters schema to ensure all fields (type, properties, required, etc.)
+    # are properly converted, including nested Type enums
+    # If no parameters provided, default to empty object schema (required by OpenAI)
+    if function_declaration.parameters:
+        parameters = _schema_to_dict(function_declaration.parameters)
+    else:
+        parameters = {
+            "type": "object",
+            "properties": {},
+        }
 
     return {
         "type": "function",
         "function": {
             "name": function_declaration.name,
             "description": function_declaration.description or "",
-            "parameters": {
-                "type": "object",
-                "properties": properties,
-            },
+            "parameters": parameters,
         },
     }
 
@@ -464,7 +515,7 @@ def _message_to_generate_content_response(
                         name=tool_call.function.name,
                         args=json.loads(tool_call.function.arguments or "{}"),
                     )
-                    part.function_call.id = tool_call.id
+                    part.function_call.id = _truncate_tool_call_id(tool_call.id)
                     parts.append(part)
                 except json.JSONDecodeError as e:
                     logger.error(
@@ -699,6 +750,11 @@ class LiteLlm(BaseLlm):
         super().__init__(model=model, **kwargs)
         self._additional_args = kwargs.copy()
 
+        # Remove handlers added by LiteLLM as they produce duplicate and misformatted logs.
+        # Logging is an application concern and libraries should not set handlers/formatters.
+        for logger_name in ["LiteLLM", "LiteLLM Proxy", "LiteLLM Router", "litellm"]:
+            logging.getLogger(logger_name).handlers.clear()
+
         # Validate and store cache strategy
         valid_strategies = ["none", "5m", "1h"]
         if cache_strategy not in valid_strategies:
@@ -882,7 +938,7 @@ class LiteLlm(BaseLlm):
                                 tool_calls.append(
                                     ChatCompletionMessageToolCall(
                                         type="function",
-                                        id=func_data["id"],
+                                        id=_truncate_tool_call_id(func_data["id"]),
                                         function=Function(
                                             name=func_data["name"],
                                             arguments=func_data["args"],
@@ -911,7 +967,7 @@ class LiteLlm(BaseLlm):
                                 tool_calls.append(
                                     ChatCompletionMessageToolCall(
                                         type="function",
-                                        id=func_data["id"],
+                                        id=_truncate_tool_call_id(func_data["id"]),
                                         function=Function(
                                             name=func_data["name"],
                                             arguments=func_data["args"],