Merge pull request #49 from redhat-community-ai-tools/GENIE-1131/STORY/Support-miltiple-mcp-providers

Genie 1131/story/support multiple mcp providers

Author: odaiodeh

multi-agent/api/flask/endpoints/resources.py

@@ -157,6 +157,54 @@ def validate_resource(resource_id, timeout_seconds):
         return jsonify({"error": str(e)}), 500
 
 
+@resources_bp.route("/resources.validate", methods=["POST"])
+@from_body({
+    "resource_ids": fields.List(fields.Str(), data_key="resourceIds", required=True),
+    "timeout_seconds": fields.Float(data_key="timeoutSeconds", load_default=10.0),
+    "max_workers": fields.Int(data_key="maxWorkers", load_default=10),
+})
+def validate_resources(resource_ids, timeout_seconds, max_workers):
+    """
+    Validate multiple resources in parallel.
+    
+    Request:
+        {
+            "resourceIds": ["rid1", "rid2", "rid3"],
+            "timeoutSeconds": 10.0,
+            "maxWorkers": 10
+        }
+        
+    Response:
+        [
+            { "element_rid": "rid1", "is_valid": true, ... },
+            { "element_rid": "rid2", "is_valid": false, ... },
+            { "element_rid": "rid3", "is_valid": true, ... }
+        ]
+        
+    Results are returned in the same order as the input resourceIds.
+    """
+    svc = current_app.container.resources_service
+    
+    # Validate input
+    if not resource_ids:
+        return jsonify([]), 200
+    
+    # Cap max_workers to prevent resource exhaustion
+    max_workers = min(max_workers, 20)
+    
+    try:
+        results = svc.validate_resources(
+            rids=resource_ids,
+            timeout_seconds=timeout_seconds,
+            max_workers=max_workers,
+        )
+        return jsonify([r.to_dict() for r in results]), 200
+    except RuntimeError as e:
+        return jsonify({"error": str(e)}), 500
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
 @resources_bp.route("/config.validate", methods=["POST"])
 @from_body({
     "category": fields.Str(required=True),

multi-agent/core/ref/models.py

@@ -1,26 +1,34 @@
-from typing import ClassVar, Literal, Annotated, Optional
-from pydantic import RootModel, model_serializer, SerializerFunctionWrapHandler, SerializationInfo, Field
+from typing import ClassVar
+from pydantic import RootModel, model_serializer, SerializerFunctionWrapHandler, SerializationInfo
 from core.enums import ResourceCategory
 
 
 class Ref(RootModel[str]):
     """
+    Base class for resource references.
+    
     A wrapper around a single string that may be:
       - a bare ID, e.g. "abcd-1234"
       - an external ref, e.g. "$ref:abcd-1234"
 
-    Exposes:
-      - .root         the original string
-      - .ref          the ID without prefix
-      - .is_external_ref()
-      - .is_inline()
-      - .get_category()  NEW: get resource category
+    All subclasses MUST define _category to specify which resource
+    category they reference. This is enforced at class definition time.
     """
     REF_PREFIX: ClassVar[str] = "$ref:"
-    _category: ClassVar[Optional[ResourceCategory]] = None
+    _category: ClassVar[ResourceCategory]
+
+    def __init_subclass__(cls, **kwargs):
+        """Enforce that all Ref subclasses define _category."""
+        super().__init_subclass__(**kwargs)
+        if not hasattr(cls, '_category') or cls._category is None:
+            raise TypeError(
+                f"Ref subclass '{cls.__name__}' must define '_category'. "
+                f"Example: _category: ClassVar[ResourceCategory] = ResourceCategory.YOUR_CATEGORY"
+            )
 
     @property
     def ref(self) -> str:
+        """The ID without the $ref: prefix."""
         raw = self.root
         if raw.startswith(self.REF_PREFIX):
             return raw[len(self.REF_PREFIX):]
@@ -31,10 +39,10 @@ def is_external_ref(self) -> bool:
 
     def is_inline(self) -> bool:
         return not self.is_external_ref()
-    
-    def get_category(self) -> Optional[ResourceCategory]:
+
+    def get_category(self) -> ResourceCategory:
         """Get the resource category this ref points to."""
-        return getattr(self.__class__, '_category', None)
+        return self._category
 
     @model_serializer(mode="wrap")
     def _serialize(self, handler: SerializerFunctionWrapHandler, info: SerializationInfo) -> str:
@@ -47,11 +55,10 @@ def _serialize(self, handler: SerializerFunctionWrapHandler, info: Serialization
         return self.ref
 
 
-# Specific Ref classes with category information + JSON schema
 class LLMRef(Ref):
     """Reference to an LLM resource."""
     _category: ClassVar[ResourceCategory] = ResourceCategory.LLM
-    
+
     model_config = {
         "json_schema_extra": {
             "category": ResourceCategory.LLM.value,
@@ -64,11 +71,11 @@ class LLMRef(Ref):
 class NodeRef(Ref):
     """Reference to a Node resource."""
     _category: ClassVar[ResourceCategory] = ResourceCategory.NODE
-    
+
     model_config = {
         "json_schema_extra": {
             "category": ResourceCategory.NODE.value,
-            "description": "Reference to a Node resource", 
+            "description": "Reference to a Node resource",
             "examples": ["$ref:custom-agent-1", "data-processor"]
         }
     }
@@ -77,7 +84,7 @@ class NodeRef(Ref):
 class RetrieverRef(Ref):
     """Reference to a Retriever resource."""
     _category: ClassVar[ResourceCategory] = ResourceCategory.RETRIEVER
-    
+
     model_config = {
         "json_schema_extra": {
             "category": ResourceCategory.RETRIEVER.value,
@@ -90,7 +97,7 @@ class RetrieverRef(Ref):
 class ToolRef(Ref):
     """Reference to a Tool resource."""
     _category: ClassVar[ResourceCategory] = ResourceCategory.TOOL
-    
+
     model_config = {
         "json_schema_extra": {
             "category": ResourceCategory.TOOL.value,
@@ -103,7 +110,7 @@ class ToolRef(Ref):
 class ProviderRef(Ref):
     """Reference to a Provider resource."""
     _category: ClassVar[ResourceCategory] = ResourceCategory.PROVIDER
-    
+
     model_config = {
         "json_schema_extra": {
             "category": ResourceCategory.PROVIDER.value,
@@ -116,7 +123,7 @@ class ProviderRef(Ref):
 class ConditionRef(Ref):
     """Reference to a Condition resource."""
     _category: ClassVar[ResourceCategory] = ResourceCategory.CONDITION
-    
+
     model_config = {
         "json_schema_extra": {
             "category": ResourceCategory.CONDITION.value,

multi-agent/elements/common/validator.py

@@ -109,6 +109,27 @@ def to_dict(self) -> Dict:
             },
         }
 
+    @classmethod
+    def create_error(cls, rid: str, error: str) -> "ElementValidationResult":
+        """
+        Factory for creating an error result.
+        
+        Useful when validation fails due to exceptions (resource not found, etc.)
+        rather than actual validation logic.
+        """
+        return cls(
+            is_valid=False,
+            element_rid=rid,
+            element_type="unknown",
+            name=None,
+            messages=[ValidationMessage(
+                severity=ValidationSeverity.ERROR,
+                code="VALIDATION_ERROR",
+                message=error,
+            )],
+            dependency_results={},
+        )
+
 
 @dataclass(frozen=True)
 class ValidationContext:

multi-agent/elements/llms/google_genai/config.py

@@ -31,7 +31,7 @@ class GoogleGenAIConfig(BaseModel):
     )
 
     max_tokens: Optional[int] = Field(
-        default=None,
+        default=8192,
         description="Maximum number of tokens to generate (None for model default)"
     )
 

multi-agent/elements/llms/google_genai/google_genai.py

@@ -6,7 +6,7 @@
 from ..common.chat.converter import LangChainConverter
 from ..common.chat.message import ChatMessage
 from ...tools.common.base_tool import BaseTool
-from ...tools.common.converter import LangChainToolsConverter
+from .tools_converter import GoogleGenAIToolsConverter
 
 
 def _extract_text_content(content: Any) -> str:
@@ -20,7 +20,6 @@ def _extract_text_content(content: Any) -> str:
     if isinstance(content, str):
         return content
     if isinstance(content, list):
-        # Extract text from content blocks
         texts = []
         for block in content:
             if isinstance(block, dict) and block.get("type") == "text":
@@ -57,7 +56,6 @@ def __init__(
         """
         self._name = "google-genai"
 
-        # Build kwargs, only including non-None values
         client_kwargs: Dict[str, Any] = {
             "model": model_name,
             "google_api_key": api_key,
@@ -99,15 +97,12 @@ def chat(
             call_params["max_output_tokens"] = max_tokens
         call_params.update(kwargs)
 
-        # Convert to LangChain message objects
         lc_messages = LangChainConverter.to_lc(messages)
-
         response = self.client.invoke(lc_messages, **call_params)
-        
-        # Google GenAI returns content as list of blocks, normalize it to string
+
         if hasattr(response, 'content') and isinstance(response.content, list):
             response.content = _extract_text_content(response.content)
-        
+
         return LangChainConverter.from_lc_message(response)
 
     def stream(
@@ -123,49 +118,34 @@ def stream(
           and, at the very end, yields **one** `ChatMessage` representing
           the full assistant reply with `tool_calls=[…]`.
         """
-        # Translate our domain history → LangChain
         lc_history = LangChainConverter.to_lc(messages)
-
-        aggregated: Any | None = None  # will hold the growing AIMessage
+        aggregated: Any | None = None
 
         for chunk in self.client.stream(lc_history, **call_params):
-            # Tool-call partials -------------------------------------------------
             if getattr(chunk, "tool_call_chunks", None):
                 aggregated = chunk if aggregated is None else aggregated + chunk
-                # we do NOT yield yet — wait until provider is done
                 continue
 
-            # Plain token path --------------------------------------------------
-            # Google GenAI returns content as list of blocks, not a simple string
             token = _extract_text_content(chunk.content)
             if token:
                 yield token
 
-        # Provider finished ------------------------------------------------------
         if aggregated:
-            # LangChain "+" produced a final AIMessage with complete tool_calls,
-            # Normalize content format before converting
             if hasattr(aggregated, 'content') and isinstance(aggregated.content, list):
                 aggregated.content = _extract_text_content(aggregated.content)
-            # Convert once to our ChatMessage model and yield it.
             yield LangChainConverter.from_lc_message(aggregated)
 
     def bind_tools(self, tools: List[BaseTool]) -> "GoogleGenAILLM":
         """
-        Return a new GoogleGenAILLM instance with tools bound, avoiding cross-contamination.
+        Return a new GoogleGenAILLM instance with tools bound.
 
-        This creates a copy of the current LLM with tools bound to the client,
-        ensuring the original LLM instance remains unchanged.
+        Uses GoogleGenAIToolsConverter which sanitizes schemas to meet
+        Google GenAI's strict validation requirements.
         """
-        # Create a shallow copy of the current instance
         new_llm = copy.copy(self)
-
-        # Create a new client with tools bound (LangChain's bind_tools returns a copy)
-        new_llm.client = self.client.bind_tools(LangChainToolsConverter.to_lc(tools))
-
+        new_llm.client = self.client.bind_tools(GoogleGenAIToolsConverter.to_lc(tools))
         return new_llm
 
     @property
     def name(self) -> str:
         return self._name
-