Fix tool filtering for MCP tools

Author: are-ces

lightspeed_stack_providers/providers/inline/agents/lightspeed_inline_agent/agents.py

@@ -97,34 +97,13 @@ async def create_openai_response(
 
         # Apply tool filtering if enabled and tools are provided
         filtered_tools = tools
-        if (
-            tools
-            and self.config.tools_filter.enabled
-            and len(tools) > self.config.tools_filter.min_tools
-        ):
-            logger.info(
-                "Tool filtering enabled - filtering %d tools (threshold: %d)",
-                len(tools),
-                self.config.tools_filter.min_tools,
-            )
+        if tools and self.config.tools_filter.enabled:
             filtered_tools = await self._filter_tools_for_response(
                 input=input,
                 tools=tools,
                 model=model,
                 conversation=conversation,
             )
-            logger.info(
-                "Tool filtering complete - reduced from %d to %d tools",
-                len(tools),
-                len(filtered_tools) if filtered_tools else 0,
-            )
-        else:
-            logger.info(
-                "Skipping tool filtering - %d tools (threshold: %d, enabled: %s)",
-                len(tools) if tools else 0,
-                self.config.tools_filter.min_tools,
-                self.config.tools_filter.enabled,
-            )
 
         # Call parent with filtered tools and temperature
         return await super().create_openai_response(
@@ -189,6 +168,20 @@ async def _filter_tools_for_response(
             logger.warning("No tool definitions found for filtering")
             return tools
 
+        if len(tools_for_filtering) <= self.config.tools_filter.min_tools:
+            logger.info(
+                "Skipping tool filtering - %d tools (threshold: %d)",
+                len(tools_for_filtering),
+                self.config.tools_filter.min_tools,
+            )
+            return tools
+
+        logger.info(
+            "Tool filtering enabled - filtering %d tools (threshold: %d)",
+            len(tools_for_filtering),
+            self.config.tools_filter.min_tools,
+        )
+
         # Extract user prompt text from input
         if isinstance(input, str):
             user_prompt = input
@@ -246,28 +239,28 @@ async def _filter_tools_for_response(
                 logger.error("Failed to parse LLM response as JSON: %s", exp)
                 filtered_tool_names = []
 
-        # Filter the original tools list
-        if filtered_tool_names or always_included_tools:
-            # Create a mapping from tool names to tool configs
-            tool_name_to_config = {}
-            for i, tool in enumerate(tools):
+        # Merge always-included tools into filtered list
+        filtered_tool_names = list(set(filtered_tool_names) | always_included_tools)
+
+        # Filter using expanded tool definitions
+        if filtered_tool_names:
+            result = []
+            for tool in tools:
                 tool_dict = tool if isinstance(tool, dict) else tool.model_dump()
-                tool_name = self._get_tool_name_from_config(tool_dict, i)
-                tool_name_to_config[tool_name] = tool
+                tool_type = tool_dict.get("type")
 
-            # Filter based on LLM response and always included tools
-            filtered_tools = [
-                tool_name_to_config[name]
-                for name in tool_name_to_config
-                if name in filtered_tool_names or name in always_included_tools
-            ]
+                if tool_type == "mcp" and len(filtered_tool_names) > 0:
+                    tool.allowed_tools = filtered_tool_names
+                    result.append(tool)
+                else:
+                    result.append(tool)
 
             logger.info(
-                "Filtered tools count: %d removed, %d remaining",
-                len(tools) - len(filtered_tools),
-                len(filtered_tools),
+                "Filtered tools: %d removed, %d remaining",
+                len(tools_for_filtering) - len(filtered_tool_names),
+                len(filtered_tool_names),
             )
-            return filtered_tools
+            return result
         else:
             logger.warning("No tools matched filtering criteria, returning empty list")
             return []
@@ -295,6 +288,9 @@ async def _get_previously_called_tools(self, conversation_id: str) -> set[str]:
                 if item_type == "function_call":
                     if hasattr(item, "name") and item.name:
                         tool_names.add(item.name)
+                elif item_type in ("mcp_call", "mcp_approval_request"):
+                    if hasattr(item, "name") and item.name:
+                        tool_names.add(item.name)
                 # Also check for nested tool_calls (legacy format)
                 elif hasattr(item, "tool_calls") and item.tool_calls:
                     for tool_call in item.tool_calls:
@@ -321,34 +317,23 @@ async def _extract_tool_definitions(
             List of dicts with tool_name and description
         """
         tool_defs = []
+        seen_tool_names: set[str] = set()
 
-        for i, tool in enumerate(tools):
+        for tool in tools:
             tool_dict = tool if isinstance(tool, dict) else tool.model_dump()
             tool_type = tool_dict.get("type")
 
             if tool_type == "mcp":
                 mcp_tools = await self._get_mcp_tool_definitions(tool_dict)
-                tool_defs.extend(mcp_tools)
-            elif tool_type == "file_search":
-                tool_defs.append(
-                    {
-                        "tool_name": "file_search",
-                        "description": "Search through uploaded files and knowledge base",
-                    }
-                )
-            elif tool_type == "function":
-                name = tool_dict.get("name", f"function_{i}")
-                description = tool_dict.get("description", "")
-                tool_defs.append({"tool_name": name, "description": description})
-            else:
-                logger.warning("Unknown tool type: %s", tool_type)
-                tool_defs.append(
-                    {
-                        "tool_name": f"{tool_type}_{i}",
-                        "description": f"Tool of type {tool_type}",
-                    }
-                )
-
+                for mcp_tool in mcp_tools:
+                    if mcp_tool["tool_name"] not in seen_tool_names:
+                        seen_tool_names.add(mcp_tool["tool_name"])
+                        tool_defs.append(mcp_tool)
+
+        logger.info(
+            "Extracted %d unique tool definitions from %d tool configs",
+            len(tool_defs), len(tools),
+        )
         return tool_defs
 
     async def _get_mcp_tool_definitions(
@@ -376,6 +361,9 @@ async def _get_mcp_tool_definitions(
             from llama_stack_api.common.content_types import URL
 
             mcp_endpoint = URL(uri=server_url)
+            # Note: llama-stack 0.4.x ignores the mcp_endpoint parameter and
+            # returns tools from ALL registered MCP servers. Deduplication is
+            # handled in _extract_tool_definitions.
             tools_response = await self.tool_runtime_api.list_runtime_tools(
                 mcp_endpoint=mcp_endpoint
             )
@@ -385,6 +373,11 @@ async def _get_mcp_tool_definitions(
                     {
                         "tool_name": tool_def.name,
                         "description": tool_def.description or "",
+                        "parameters": (
+                            tool_def.parameters
+                            if hasattr(tool_def, "parameters")
+                            else {}
+                        ),
                     }
                 )
 

resources/external_providers/inline/agents/lightspeed_inline_agent.yaml

@@ -2,5 +2,5 @@ adapter_type: lightspeed_inline_agent
 pip_packages: []
 config_class: lightspeed_stack_providers.providers.inline.agents.lightspeed_inline_agent.config.LightspeedAgentsImplConfig
 module: lightspeed_stack_providers.providers.inline.agents.lightspeed_inline_agent
-api_dependencies: [ inference, safety, vector_io, vector_stores, tool_runtime, tool_groups ]
-optional_api_dependencies: []
+api_dependencies: [ inference, vector_io, tool_runtime, tool_groups, conversations, prompts, files ]
+optional_api_dependencies: [ safety ]

run.yaml

@@ -6,6 +6,8 @@ apis:
   - vector_io
   - agents
   - tool_runtime
+  - vector_io
+  - files
 
 external_providers_dir: ./resources/external_providers
 
@@ -32,6 +34,16 @@ storage:
       backend: kv_default
 
 providers:
+
+  files:
+    - provider_id: meta-reference-files
+      provider_type: inline::localfs
+      config:
+        storage_dir: ${env.FILES_STORAGE_DIR:=/tmp/llama_files}
+        metadata_store:
+          table_name: files_metadata
+          backend: sql_default
+
   inference:
     - provider_id: openai
       provider_type: remote::openai
@@ -42,7 +54,7 @@ providers:
     - provider_id: lightspeed_question_validity
       provider_type: inline::lightspeed_question_validity
       config:
-        model_id: openai/gpt-4o
+        model_id: openai/gpt-4o-mini
         temperature: 0.0
         invalid_question_response: |
           Hi, I'm the OpenShift Lightspeed assistant, I can help you with questions about OpenShift,
@@ -88,6 +100,11 @@ vector_stores:
           - pattern: "\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}\\b"
             replacement: "[REDACTED_EMAIL]"
 
+  tool_runtime:
+    - provider_id: model-context-protocol
+      provider_type: remote::model-context-protocol
+      config: {}
+
   agents:
     - provider_id: lightspeed_inline_agent
       provider_type: inline::lightspeed_inline_agent
@@ -108,11 +125,6 @@ vector_stores:
         chatbot_temperature_override: 1.0
 
 registered_resources:
-  models:
-    - model_id: gpt-4o
-      provider_id: openai
-      model_type: llm
-      provider_model_id: gpt-4o
 
   shields:
     - shield_id: lightspeed_question_validity-shield
@@ -121,7 +133,11 @@ registered_resources:
       provider_id: lightspeed_redaction
       provider_shield_id: lightspeed-redaction-shield
 
-  tool_groups: []
+  tool_groups:
+    - toolgroup_id: openshift-tools
+      provider_id: model-context-protocol
+      mcp_endpoint:
+        uri: http://localhost:8401/sse
 
 server:
   host: 0.0.0.0