fix: correct tool-calling content handling and schema serialization

- fix(gemini): prevent tool calls from using stale text content; correct key refs
- fix(agent-executor): resolve type errors
- refactor(schema): extract Pydantic schema utilities from platform tools
- fix(schema): properly serialize schemas and ensure Responses API uses a separate structure
- fix: preserve list identity to avoid mutation/aliasing issues
- chore(tests): update assumptions to match new behavior

lib/crewai-tools/src/crewai_tools/tools/crewai_platform_tools/crewai_platform_action_tool.py

@@ -1,10 +1,11 @@
 """Crewai Enterprise Tools."""
-import os
+
 import json
-import re
-from typing import Any, Optional, Union, cast, get_origin
+import os
+from typing import Any
 
 from crewai.tools import BaseTool
+from crewai.utilities.pydantic_schema_utils import create_model_from_schema
 from pydantic import Field, create_model
 import requests
 
@@ -14,77 +15,6 @@ from crewai_tools.tools.crewai_platform_tools.misc import (
 )
 
 
-class AllOfSchemaAnalyzer:
-    """Helper class to analyze and merge allOf schemas."""
-
-    def __init__(self, schemas: list[dict[str, Any]]):
-        self.schemas = schemas
-        self._explicit_types: list[str] = []
-        self._merged_properties: dict[str, Any] = {}
-        self._merged_required: list[str] = []
-        self._analyze_schemas()
-
-    def _analyze_schemas(self) -> None:
-        """Analyze all schemas and extract relevant information."""
-        for schema in self.schemas:
-            if "type" in schema:
-                self._explicit_types.append(schema["type"])
-
-            # Merge object properties
-            if schema.get("type") == "object" and "properties" in schema:
-                self._merged_properties.update(schema["properties"])
-                if "required" in schema:
-                    self._merged_required.extend(schema["required"])
-
-    def has_consistent_type(self) -> bool:
-        """Check if all schemas have the same explicit type."""
-        return len(set(self._explicit_types)) == 1 if self._explicit_types else False
-
-    def get_consistent_type(self) -> type[Any]:
-        """Get the consistent type if all schemas agree."""
-        if not self.has_consistent_type():
-            raise ValueError("No consistent type found")
-
-        type_mapping = {
-            "string": str,
-            "integer": int,
-            "number": float,
-            "boolean": bool,
-            "array": list,
-            "object": dict,
-            "null": type(None),
-        }
-        return type_mapping.get(self._explicit_types[0], str)
-
-    def has_object_schemas(self) -> bool:
-        """Check if any schemas are object types with properties."""
-        return bool(self._merged_properties)
-
-    def get_merged_properties(self) -> dict[str, Any]:
-        """Get merged properties from all object schemas."""
-        return self._merged_properties
-
-    def get_merged_required_fields(self) -> list[str]:
-        """Get merged required fields from all object schemas."""
-        return list(set(self._merged_required))  # Remove duplicates
-
-    def get_fallback_type(self) -> type[Any]:
-        """Get a fallback type when merging fails."""
-        if self._explicit_types:
-            # Use the first explicit type
-            type_mapping = {
-                "string": str,
-                "integer": int,
-                "number": float,
-                "boolean": bool,
-                "array": list,
-                "object": dict,
-                "null": type(None),
-            }
-            return type_mapping.get(self._explicit_types[0], str)
-        return str
-
-
 class CrewAIPlatformActionTool(BaseTool):
     action_name: str = Field(default="", description="The name of the action")
     action_schema: dict[str, Any] = Field(
@@ -97,42 +27,19 @@ class CrewAIPlatformActionTool(BaseTool):
         action_name: str,
         action_schema: dict[str, Any],
     ):
-        self._model_registry: dict[str, type[Any]] = {}
-        self._base_name = self._sanitize_name(action_name)
-
-        schema_props, required = self._extract_schema_info(action_schema)
-
-        field_definitions: dict[str, Any] = {}
-        for param_name, param_details in schema_props.items():
-            param_desc = param_details.get("description", "")
-            is_required = param_name in required
+        parameters = action_schema.get("function", {}).get("parameters", {})
 
+        if parameters and parameters.get("properties"):
             try:
-                field_type = self._process_schema_type(
-                    param_details, self._sanitize_name(param_name).title()
-                )
+                if "title" not in parameters:
+                    parameters = {**parameters, "title": f"{action_name}Schema"}
+                if "type" not in parameters:
+                    parameters = {**parameters, "type": "object"}
+                args_schema = create_model_from_schema(parameters)
             except Exception:
-                field_type = str
-
-            field_definitions[param_name] = self._create_field_definition(
-                field_type, is_required, param_desc
-            )
-
-        if field_definitions:
-            try:
-                args_schema = create_model(
-                    f"{self._base_name}Schema", **field_definitions
-                )
-            except Exception:
-                args_schema = create_model(
-                    f"{self._base_name}Schema",
-                    input_text=(str, Field(description="Input for the action")),
-                )
+                args_schema = create_model(f"{action_name}Schema")
         else:
-            args_schema = create_model(
-                f"{self._base_name}Schema",
-                input_text=(str, Field(description="Input for the action")),
-            )
+            args_schema = create_model(f"{action_name}Schema")
 
         super().__init__(
             name=action_name.lower().replace(" ", "_"),
@@ -142,285 +49,12 @@ class CrewAIPlatformActionTool(BaseTool):
         self.action_name = action_name
         self.action_schema = action_schema
 
-    @staticmethod
-    def _sanitize_name(name: str) -> str:
-        name = name.lower().replace(" ", "_")
-        sanitized = re.sub(r"[^a-zA-Z0-9_]", "", name)
-        parts = sanitized.split("_")
-        return "".join(word.capitalize() for word in parts if word)
-
-    @staticmethod
-    def _extract_schema_info(
-        action_schema: dict[str, Any],
-    ) -> tuple[dict[str, Any], list[str]]:
-        schema_props = (
-            action_schema.get("function", {})
-            .get("parameters", {})
-            .get("properties", {})
-        )
-        required = (
-            action_schema.get("function", {}).get("parameters", {}).get("required", [])
-        )
-        return schema_props, required
-
-    def _process_schema_type(self, schema: dict[str, Any], type_name: str) -> type[Any]:
-        """
-        Process a JSON Schema type definition into a Python type.
-
-        Handles complex schema constructs like anyOf, oneOf, allOf, enums, arrays, and objects.
-        """
-        # Handle composite schema types (anyOf, oneOf, allOf)
-        if composite_type := self._process_composite_schema(schema, type_name):
-            return composite_type
-
-        # Handle primitive types and simple constructs
-        return self._process_primitive_schema(schema, type_name)
-
-    def _process_composite_schema(
-        self, schema: dict[str, Any], type_name: str
-    ) -> type[Any] | None:
-        """Process composite schema types: anyOf, oneOf, allOf."""
-        if "anyOf" in schema:
-            return self._process_any_of_schema(schema["anyOf"], type_name)
-        if "oneOf" in schema:
-            return self._process_one_of_schema(schema["oneOf"], type_name)
-        if "allOf" in schema:
-            return self._process_all_of_schema(schema["allOf"], type_name)
-        return None
-
-    def _process_any_of_schema(
-        self, any_of_types: list[dict[str, Any]], type_name: str
-    ) -> type[Any]:
-        """Process anyOf schema - creates Union of possible types."""
-        is_nullable = any(t.get("type") == "null" for t in any_of_types)
-        non_null_types = [t for t in any_of_types if t.get("type") != "null"]
-
-        if not non_null_types:
-            return cast(
-                type[Any], cast(object, str | None)
-            )  # fallback for only-null case
-
-        base_type = (
-            self._process_schema_type(non_null_types[0], type_name)
-            if len(non_null_types) == 1
-            else self._create_union_type(non_null_types, type_name, "AnyOf")
-        )
-        return base_type | None if is_nullable else base_type  # type: ignore[return-value]
-
-    def _process_one_of_schema(
-        self, one_of_types: list[dict[str, Any]], type_name: str
-    ) -> type[Any]:
-        """Process oneOf schema - creates Union of mutually exclusive types."""
-        return (
-            self._process_schema_type(one_of_types[0], type_name)
-            if len(one_of_types) == 1
-            else self._create_union_type(one_of_types, type_name, "OneOf")
-        )
-
-    def _process_all_of_schema(
-        self, all_of_schemas: list[dict[str, Any]], type_name: str
-    ) -> type[Any]:
-        """Process allOf schema - merges schemas that must all be satisfied."""
-        if len(all_of_schemas) == 1:
-            return self._process_schema_type(all_of_schemas[0], type_name)
-        return self._merge_all_of_schemas(all_of_schemas, type_name)
-
-    def _create_union_type(
-        self, schemas: list[dict[str, Any]], type_name: str, prefix: str
-    ) -> type[Any]:
-        """Create a Union type from multiple schemas."""
-        return Union[  # type: ignore  # noqa: UP007
-            tuple(
-                self._process_schema_type(schema, f"{type_name}{prefix}{i}")
-                for i, schema in enumerate(schemas)
-            )
-        ]
-
-    def _process_primitive_schema(
-        self, schema: dict[str, Any], type_name: str
-    ) -> type[Any]:
-        """Process primitive schema types: string, number, array, object, etc."""
-        json_type = schema.get("type", "string")
-
-        if "enum" in schema:
-            return self._process_enum_schema(schema, json_type)
-
-        if json_type == "array":
-            return self._process_array_schema(schema, type_name)
-
-        if json_type == "object":
-            return self._create_nested_model(schema, type_name)
-
-        return self._map_json_type_to_python(json_type)
-
-    def _process_enum_schema(self, schema: dict[str, Any], json_type: str) -> type[Any]:
-        """Process enum schema - currently falls back to base type."""
-        enum_values = schema["enum"]
-        if not enum_values:
-            return self._map_json_type_to_python(json_type)
-
-        # For Literal types, we need to pass the values directly, not as a tuple
-        # This is a workaround since we can't dynamically create Literal types easily
-        # Fall back to the base JSON type for now
-        return self._map_json_type_to_python(json_type)
-
-    def _process_array_schema(
-        self, schema: dict[str, Any], type_name: str
-    ) -> type[Any]:
-        items_schema = schema.get("items", {"type": "string"})
-        item_type = self._process_schema_type(items_schema, f"{type_name}Item")
-        return list[item_type]  # type: ignore
-
-    def _merge_all_of_schemas(
-        self, schemas: list[dict[str, Any]], type_name: str
-    ) -> type[Any]:
-        schema_analyzer = AllOfSchemaAnalyzer(schemas)
-
-        if schema_analyzer.has_consistent_type():
-            return schema_analyzer.get_consistent_type()
-
-        if schema_analyzer.has_object_schemas():
-            return self._create_merged_object_model(
-                schema_analyzer.get_merged_properties(),
-                schema_analyzer.get_merged_required_fields(),
-                type_name,
-            )
-
-        return schema_analyzer.get_fallback_type()
-
-    def _create_merged_object_model(
-        self, properties: dict[str, Any], required: list[str], model_name: str
-    ) -> type[Any]:
-        full_model_name = f"{self._base_name}{model_name}AllOf"
-
-        if full_model_name in self._model_registry:
-            return self._model_registry[full_model_name]
-
-        if not properties:
-            return dict
-
-        field_definitions = self._build_field_definitions(
-            properties, required, model_name
-        )
-
-        try:
-            merged_model = create_model(full_model_name, **field_definitions)
-            self._model_registry[full_model_name] = merged_model
-            return merged_model
-        except Exception:
-            return dict
-
-    def _build_field_definitions(
-        self, properties: dict[str, Any], required: list[str], model_name: str
-    ) -> dict[str, Any]:
-        field_definitions = {}
-
-        for prop_name, prop_schema in properties.items():
-            prop_desc = prop_schema.get("description", "")
-            is_required = prop_name in required
-
-            try:
-                prop_type = self._process_schema_type(
-                    prop_schema, f"{model_name}{self._sanitize_name(prop_name).title()}"
-                )
-            except Exception:
-                prop_type = str
-
-            field_definitions[prop_name] = self._create_field_definition(
-                prop_type, is_required, prop_desc
-            )
-
-        return field_definitions
-
-    def _create_nested_model(
-        self, schema: dict[str, Any], model_name: str
-    ) -> type[Any]:
-        full_model_name = f"{self._base_name}{model_name}"
-
-        if full_model_name in self._model_registry:
-            return self._model_registry[full_model_name]
-
-        properties = schema.get("properties", {})
-        required_fields = schema.get("required", [])
-
-        if not properties:
-            return dict
-
-        field_definitions = {}
-        for prop_name, prop_schema in properties.items():
-            prop_desc = prop_schema.get("description", "")
-            is_required = prop_name in required_fields
-
-            try:
-                prop_type = self._process_schema_type(
-                    prop_schema, f"{model_name}{self._sanitize_name(prop_name).title()}"
-                )
-            except Exception:
-                prop_type = str
-
-            field_definitions[prop_name] = self._create_field_definition(
-                prop_type, is_required, prop_desc
-            )
-
-        try:
-            nested_model = create_model(full_model_name, **field_definitions)  # type: ignore
-            self._model_registry[full_model_name] = nested_model
-            return nested_model
-        except Exception:
-            return dict
-
-    def _create_field_definition(
-        self, field_type: type[Any], is_required: bool, description: str
-    ) -> tuple:
-        if is_required:
-            return (field_type, Field(description=description))
-        if get_origin(field_type) is Union:
-            return (field_type, Field(default=None, description=description))
-        return (
-            Optional[field_type],  # noqa: UP045
-            Field(default=None, description=description),
-        )
-
-    def _map_json_type_to_python(self, json_type: str) -> type[Any]:
-        type_mapping = {
-            "string": str,
-            "integer": int,
-            "number": float,
-            "boolean": bool,
-            "array": list,
-            "object": dict,
-            "null": type(None),
-        }
-        return type_mapping.get(json_type, str)
-
-    def _get_required_nullable_fields(self) -> list[str]:
-        schema_props, required = self._extract_schema_info(self.action_schema)
-
-        required_nullable_fields = []
-        for param_name in required:
-            param_details = schema_props.get(param_name, {})
-            if self._is_nullable_type(param_details):
-                required_nullable_fields.append(param_name)
-
-        return required_nullable_fields
-
-    def _is_nullable_type(self, schema: dict[str, Any]) -> bool:
-        if "anyOf" in schema:
-            return any(t.get("type") == "null" for t in schema["anyOf"])
-        return schema.get("type") == "null"
-
-    def _run(self, **kwargs) -> str:
+    def _run(self, **kwargs: Any) -> str:
         try:
             cleaned_kwargs = {
                 key: value for key, value in kwargs.items() if value is not None
             }
 
-            required_nullable_fields = self._get_required_nullable_fields()
-
-            for field_name in required_nullable_fields:
-                if field_name not in cleaned_kwargs:
-                    cleaned_kwargs[field_name] = None
-
             api_url = (
                 f"{get_platform_api_base_url()}/actions/{self.action_name}/execute"
             )
@@ -429,7 +63,9 @@ class CrewAIPlatformActionTool(BaseTool):
                 "Authorization": f"Bearer {token}",
                 "Content-Type": "application/json",
             }
-            payload = cleaned_kwargs
+            payload = {
+                "integration": cleaned_kwargs if cleaned_kwargs else {"_noop": True}
+            }
 
             response = requests.post(
                 url=api_url,
@@ -441,7 +77,14 @@ class CrewAIPlatformActionTool(BaseTool):
 
             data = response.json()
             if not response.ok:
-                error_message = data.get("error", {}).get("message", json.dumps(data))
+                if isinstance(data, dict):
+                    error_info = data.get("error", {})
+                    if isinstance(error_info, dict):
+                        error_message = error_info.get("message", json.dumps(data))
+                    else:
+                        error_message = str(error_info)
+                else:
+                    error_message = str(data)
                 return f"API request failed: {error_message}"
 
             return json.dumps(data, indent=2)

lib/crewai-tools/src/crewai_tools/tools/crewai_platform_tools/crewai_platform_tool_builder.py

@@ -1,5 +1,10 @@
-from typing import Any
+"""CrewAI platform tool builder for fetching and creating action tools."""
+
+import logging
 import os
+from types import TracebackType
+from typing import Any
+
 from crewai.tools import BaseTool
 import requests
 
@@ -12,22 +17,29 @@ from crewai_tools.tools.crewai_platform_tools.misc import (
 )
 
 
+logger = logging.getLogger(__name__)
+
+
 class CrewaiPlatformToolBuilder:
+    """Builds platform tools from remote action schemas."""
+
     def __init__(
         self,
         apps: list[str],
-    ):
+    ) -> None:
         self._apps = apps
-        self._actions_schema = {}  # type: ignore[var-annotated]
-        self._tools = None
+        self._actions_schema: dict[str, dict[str, Any]] = {}
+        self._tools: list[BaseTool] | None = None
 
     def tools(self) -> list[BaseTool]:
+        """Fetch actions and return built tools."""
         if self._tools is None:
             self._fetch_actions()
             self._create_tools()
         return self._tools if self._tools is not None else []
 
-    def _fetch_actions(self):
+    def _fetch_actions(self) -> None:
+        """Fetch action schemas from the platform API."""
         actions_url = f"{get_platform_api_base_url()}/actions"
         headers = {"Authorization": f"Bearer {get_platform_integration_token()}"}
 
@@ -40,7 +52,8 @@ class CrewaiPlatformToolBuilder:
                 verify=os.environ.get("CREWAI_FACTORY", "false").lower() != "true",
             )
             response.raise_for_status()
-        except Exception:
+        except Exception as e:
+            logger.error(f"Failed to fetch platform tools for apps {self._apps}: {e}")
             return
 
         raw_data = response.json()
@@ -51,6 +64,8 @@ class CrewaiPlatformToolBuilder:
         for app, action_list in action_categories.items():
             if isinstance(action_list, list):
                 for action in action_list:
+                    if not isinstance(action, dict):
+                        continue
                     if action_name := action.get("name"):
                         action_schema = {
                             "function": {
@@ -64,72 +79,16 @@ class CrewaiPlatformToolBuilder:
                         }
                         self._actions_schema[action_name] = action_schema
 
-    def _generate_detailed_description(
-        self, schema: dict[str, Any], indent: int = 0
-    ) -> list[str]:
-        descriptions = []
-        indent_str = "  " * indent
-
-        schema_type = schema.get("type", "string")
-
-        if schema_type == "object":
-            properties = schema.get("properties", {})
-            required_fields = schema.get("required", [])
-
-            if properties:
-                descriptions.append(f"{indent_str}Object with properties:")
-                for prop_name, prop_schema in properties.items():
-                    prop_desc = prop_schema.get("description", "")
-                    is_required = prop_name in required_fields
-                    req_str = " (required)" if is_required else " (optional)"
-                    descriptions.append(
-                        f"{indent_str}  - {prop_name}: {prop_desc}{req_str}"
-                    )
-
-                    if prop_schema.get("type") == "object":
-                        descriptions.extend(
-                            self._generate_detailed_description(prop_schema, indent + 2)
-                        )
-                    elif prop_schema.get("type") == "array":
-                        items_schema = prop_schema.get("items", {})
-                        if items_schema.get("type") == "object":
-                            descriptions.append(f"{indent_str}    Array of objects:")
-                            descriptions.extend(
-                                self._generate_detailed_description(
-                                    items_schema, indent + 3
-                                )
-                            )
-                        elif "enum" in items_schema:
-                            descriptions.append(
-                                f"{indent_str}    Array of enum values: {items_schema['enum']}"
-                            )
-                    elif "enum" in prop_schema:
-                        descriptions.append(
-                            f"{indent_str}    Enum values: {prop_schema['enum']}"
-                        )
-
-        return descriptions
-
-    def _create_tools(self):
-        tools = []
+    def _create_tools(self) -> None:
+        """Create tool instances from fetched action schemas."""
+        tools: list[BaseTool] = []
 
         for action_name, action_schema in self._actions_schema.items():
             function_details = action_schema.get("function", {})
             description = function_details.get("description", f"Execute {action_name}")
 
-            parameters = function_details.get("parameters", {})
-            param_descriptions = []
-
-            if parameters.get("properties"):
-                param_descriptions.append("\nDetailed Parameter Structure:")
-                param_descriptions.extend(
-                    self._generate_detailed_description(parameters)
-                )
-
-            full_description = description + "\n".join(param_descriptions)
-
             tool = CrewAIPlatformActionTool(
-                description=full_description,
+                description=description,
                 action_name=action_name,
                 action_schema=action_schema,
             )
@@ -138,8 +97,14 @@ class CrewaiPlatformToolBuilder:
 
         self._tools = tools
 
-    def __enter__(self):
+    def __enter__(self) -> list[BaseTool]:
+        """Enter context manager and return tools."""
         return self.tools()
 
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        pass
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Exit context manager."""

lib/crewai-tools/tests/tools/crewai_platform_tools/test_crewai_platform_action_tool.py

@@ -1,4 +1,3 @@
-from typing import Union, get_args, get_origin
 from unittest.mock import patch, Mock
 import os
 
@@ -7,251 +6,6 @@ from crewai_tools.tools.crewai_platform_tools.crewai_platform_action_tool import
 )
 
 
-class TestSchemaProcessing:
-
-    def setup_method(self):
-        self.base_action_schema = {
-            "function": {
-                "parameters": {
-                    "properties": {},
-                    "required": []
-                }
-            }
-        }
-
-    def create_test_tool(self, action_name="test_action"):
-        return CrewAIPlatformActionTool(
-            description="Test tool",
-            action_name=action_name,
-            action_schema=self.base_action_schema
-        )
-
-    def test_anyof_multiple_types(self):
-        tool = self.create_test_tool()
-
-        test_schema = {
-            "anyOf": [
-                {"type": "string"},
-                {"type": "number"},
-                {"type": "integer"}
-            ]
-        }
-
-        result_type = tool._process_schema_type(test_schema, "TestField")
-
-        assert get_origin(result_type) is Union
-
-        args = get_args(result_type)
-        expected_types = (str, float, int)
-
-        for expected_type in expected_types:
-            assert expected_type in args
-
-    def test_anyof_with_null(self):
-        tool = self.create_test_tool()
-
-        test_schema = {
-            "anyOf": [
-                {"type": "string"},
-                {"type": "number"},
-                {"type": "null"}
-            ]
-        }
-
-        result_type = tool._process_schema_type(test_schema, "TestFieldNullable")
-
-        assert get_origin(result_type) is Union
-
-        args = get_args(result_type)
-        assert type(None) in args
-        assert str in args
-        assert float in args
-
-    def test_anyof_single_type(self):
-        tool = self.create_test_tool()
-
-        test_schema = {
-            "anyOf": [
-                {"type": "string"}
-            ]
-        }
-
-        result_type = tool._process_schema_type(test_schema, "TestFieldSingle")
-
-        assert result_type is str
-
-    def test_oneof_multiple_types(self):
-        tool = self.create_test_tool()
-
-        test_schema = {
-            "oneOf": [
-                {"type": "string"},
-                {"type": "boolean"}
-            ]
-        }
-
-        result_type = tool._process_schema_type(test_schema, "TestFieldOneOf")
-
-        assert get_origin(result_type) is Union
-
-        args = get_args(result_type)
-        expected_types = (str, bool)
-
-        for expected_type in expected_types:
-            assert expected_type in args
-
-    def test_oneof_single_type(self):
-        tool = self.create_test_tool()
-
-        test_schema = {
-            "oneOf": [
-                {"type": "integer"}
-            ]
-        }
-
-        result_type = tool._process_schema_type(test_schema, "TestFieldOneOfSingle")
-
-        assert result_type is int
-
-    def test_basic_types(self):
-        tool = self.create_test_tool()
-
-        test_cases = [
-            ({"type": "string"}, str),
-            ({"type": "integer"}, int),
-            ({"type": "number"}, float),
-            ({"type": "boolean"}, bool),
-            ({"type": "array", "items": {"type": "string"}}, list),
-        ]
-
-        for schema, expected_type in test_cases:
-            result_type = tool._process_schema_type(schema, "TestField")
-            if schema["type"] == "array":
-                assert get_origin(result_type) is list
-            else:
-                assert result_type is expected_type
-
-    def test_enum_handling(self):
-        tool = self.create_test_tool()
-
-        test_schema = {
-            "type": "string",
-            "enum": ["option1", "option2", "option3"]
-        }
-
-        result_type = tool._process_schema_type(test_schema, "TestFieldEnum")
-
-        assert result_type is str
-
-    def test_nested_anyof(self):
-        tool = self.create_test_tool()
-
-        test_schema = {
-            "anyOf": [
-                {"type": "string"},
-                {
-                    "anyOf": [
-                        {"type": "integer"},
-                        {"type": "boolean"}
-                    ]
-                }
-            ]
-        }
-
-        result_type = tool._process_schema_type(test_schema, "TestFieldNested")
-
-        assert get_origin(result_type) is Union
-        args = get_args(result_type)
-
-        assert str in args
-
-        if len(args) == 3:
-            assert int in args
-            assert bool in args
-        else:
-            nested_union = next(arg for arg in args if get_origin(arg) is Union)
-            nested_args = get_args(nested_union)
-            assert int in nested_args
-            assert bool in nested_args
-
-    def test_allof_same_types(self):
-        tool = self.create_test_tool()
-
-        test_schema = {
-            "allOf": [
-                {"type": "string"},
-                {"type": "string", "maxLength": 100}
-            ]
-        }
-
-        result_type = tool._process_schema_type(test_schema, "TestFieldAllOfSame")
-
-        assert result_type is str
-
-    def test_allof_object_merge(self):
-        tool = self.create_test_tool()
-
-        test_schema = {
-            "allOf": [
-                {
-                    "type": "object",
-                    "properties": {
-                        "name": {"type": "string"},
-                        "age": {"type": "integer"}
-                    },
-                    "required": ["name"]
-                },
-                {
-                    "type": "object",
-                    "properties": {
-                        "email": {"type": "string"},
-                            "age": {"type": "integer"}
-                    },
-                    "required": ["email"]
-                }
-            ]
-        }
-
-        result_type = tool._process_schema_type(test_schema, "TestFieldAllOfMerged")
-
-        # Should create a merged model with all properties
-        # The implementation might fall back to dict if model creation fails
-        # Let's just verify it's not a basic scalar type
-        assert result_type is not str
-        assert result_type is not int
-        assert result_type is not bool
-        # It could be dict (fallback) or a proper model class
-        assert result_type in (dict, type) or hasattr(result_type, '__name__')
-
-    def test_allof_single_schema(self):
-        """Test that allOf with single schema works correctly."""
-        tool = self.create_test_tool()
-
-        test_schema = {
-            "allOf": [
-                {"type": "boolean"}
-            ]
-        }
-
-        result_type = tool._process_schema_type(test_schema, "TestFieldAllOfSingle")
-
-        # Should be just bool
-        assert result_type is bool
-
-    def test_allof_mixed_types(self):
-        tool = self.create_test_tool()
-
-        test_schema = {
-            "allOf": [
-                {"type": "string"},
-                {"type": "integer"}
-            ]
-        }
-
-        result_type = tool._process_schema_type(test_schema, "TestFieldAllOfMixed")
-
-        assert result_type is str
-
 class TestCrewAIPlatformActionToolVerify:
     """Test suite for SSL verification behavior based on CREWAI_FACTORY environment variable"""
 

lib/crewai-tools/tests/tools/crewai_platform_tools/test_crewai_platform_tool_builder.py

@@ -224,43 +224,6 @@ class TestCrewaiPlatformToolBuilder(unittest.TestCase):
             _, kwargs = mock_get.call_args
             assert kwargs["params"]["apps"] == ""
 
-    def test_detailed_description_generation(self):
-        builder = CrewaiPlatformToolBuilder(apps=["test"])
-
-        complex_schema = {
-            "type": "object",
-            "properties": {
-                "simple_string": {"type": "string", "description": "A simple string"},
-                "nested_object": {
-                    "type": "object",
-                    "properties": {
-                        "inner_prop": {
-                            "type": "integer",
-                            "description": "Inner property",
-                        }
-                    },
-                    "description": "Nested object",
-                },
-                "array_prop": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Array of strings",
-                },
-            },
-        }
-
-        descriptions = builder._generate_detailed_description(complex_schema)
-
-        assert isinstance(descriptions, list)
-        assert len(descriptions) > 0
-
-        description_text = "\n".join(descriptions)
-        assert "simple_string" in description_text
-        assert "nested_object" in description_text
-        assert "array_prop" in description_text
-
-
-
 class TestCrewaiPlatformToolBuilderVerify(unittest.TestCase):
     """Test suite for SSL verification behavior in CrewaiPlatformToolBuilder"""