Rename output_schema to result_schema to avoid name clashing

Author: vinibrsl

lib/crewai-tools/src/crewai_tools/tools/tavily_research_tool/tavily_research_tool.py

@@ -7,14 +7,7 @@
 
 from crewai.tools import BaseTool, EnvVar
 from dotenv import load_dotenv
-from pydantic import (
-    BaseModel,
-    ConfigDict,
-    Field,
-    PrivateAttr,
-    field_serializer,
-    field_validator,
-)
+from pydantic import BaseModel, ConfigDict, Field, PrivateAttr
 
 
 load_dotenv()
@@ -70,11 +63,7 @@ class TavilyResearchTool(BaseTool):
         default="auto",
         description="Default model used for new Tavily research tasks.",
     )
-    # ``output_schema`` here is a Tavily API JSON Schema (a dict), not the
-    # Pydantic model type that ``BaseTool.output_schema`` expects. Tavily
-    # deliberately repurposes the inherited name for its own released parameter,
-    # so the type intentionally diverges from the base class.
-    output_schema: dict[str, Any] | None = Field(  # type: ignore[assignment]
+    output_schema: dict[str, Any] | None = Field(
         default=None,
         description="Default JSON Schema used to structure research output.",
     )
@@ -97,26 +86,7 @@ class TavilyResearchTool(BaseTool):
         ]
     )
 
-    # Override the inherited validator/serializer so the framework's
-    # model-coercion logic leaves Tavily's JSON Schema dict untouched.
-    @field_validator("output_schema", mode="before")
-    @classmethod
-    def _default_output_schema(  # type: ignore[override]
-        cls, v: dict[str, Any] | None
-    ) -> dict[str, Any] | None:
-        return v
-
-    @field_serializer("output_schema", when_used="json")
-    def _serialize_output_schema(  # type: ignore[override]
-        self, schema: dict[str, Any] | None
-    ) -> dict[str, Any] | None:
-        return schema
-
     def __init__(self, **kwargs: Any):
-        tavily_output_schema = kwargs.pop("tavily_output_schema", None)
-        if "output_schema" not in kwargs and tavily_output_schema is not None:
-            kwargs["output_schema"] = tavily_output_schema
-
         super().__init__(**kwargs)
         if TAVILY_AVAILABLE:
             api_key = os.getenv("TAVILY_API_KEY")

lib/crewai-tools/tests/tools/tavily_research_tool_test.py

@@ -25386,6 +25386,20 @@
             "title": "Model",
             "type": "string"
           },
+          "output_schema": {
+            "anyOf": [
+              {
+                "additionalProperties": true,
+                "type": "object"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "default": null,
+            "description": "Default JSON Schema used to structure research output.",
+            "title": "Output Schema"
+          },
           "stream": {
             "default": false,
             "description": "Whether new Tavily research tasks should stream responses by default.",

lib/crewai-tools/tool.specs.json

@@ -34,7 +34,7 @@
     CrewStructuredTool,
     _deserialize_schema,
     _format_tool_output_for_agent,
-    _infer_output_schema_from_callable,
+    _infer_result_schema_from_callable,
     _serialize_schema,
     build_schema_hint,
 )
@@ -151,7 +151,7 @@ def _validate_tool(value: Any, nxt: Any) -> Any:
         validate_default=True,
         description="The schema for the arguments that the tool accepts.",
     )
-    output_schema: type[PydanticBaseModel] | None = Field(
+    result_schema: type[PydanticBaseModel] | None = Field(
         default=None,
         validate_default=True,
         description="The schema for the output that the tool returns.",
@@ -163,8 +163,8 @@ def _serialize_args_schema(
     ) -> dict[str, Any] | None:
         return _serialize_schema(schema)
 
-    @field_serializer("output_schema", when_used="json")
-    def _serialize_output_schema(
+    @field_serializer("result_schema", when_used="json")
+    def _serialize_result_schema(
         self, schema: type[PydanticBaseModel] | None
     ) -> dict[str, Any] | None:
         return _serialize_schema(schema)
@@ -246,16 +246,16 @@ def _default_args_schema(
 
         return create_model(f"{cls.__name__}Schema", **fields)
 
-    @field_validator("output_schema", mode="before")
+    @field_validator("result_schema", mode="before")
     @classmethod
-    def _default_output_schema(
+    def _default_result_schema(
         cls, v: type[PydanticBaseModel] | dict[str, Any] | None
     ) -> type[PydanticBaseModel] | None:
         if isinstance(v, dict):
             return _deserialize_schema(v)
         if v is not None:
             return v
-        return _infer_output_schema_from_callable(cls._run)
+        return _infer_result_schema_from_callable(cls._run)
 
     @field_validator("max_usage_count", mode="before")
     @classmethod
@@ -397,7 +397,7 @@ def to_structured_tool(self) -> CrewStructuredTool:
             name=self.name,
             description=self.description,
             args_schema=self.args_schema,
-            output_schema=self.output_schema,
+            result_schema=self.result_schema,
             func=self._run,
             result_as_answer=self.result_as_answer,
             max_usage_count=self.max_usage_count,
@@ -419,9 +419,9 @@ def from_langchain(cls, tool: Any) -> BaseTool:
             raise ValueError("The provided tool must have a callable 'func' attribute.")
 
         args_schema = getattr(tool, "args_schema", None)
-        output_schema = getattr(tool, "output_schema", None)
-        if output_schema is None:
-            output_schema = _infer_output_schema_from_callable(tool.func)
+        result_schema = getattr(tool, "result_schema", None)
+        if result_schema is None:
+            result_schema = _infer_result_schema_from_callable(tool.func)
 
         if args_schema is None:
             func_signature = signature(tool.func)
@@ -452,7 +452,7 @@ def from_langchain(cls, tool: Any) -> BaseTool:
             description=getattr(tool, "description", ""),
             func=tool.func,
             args_schema=args_schema,
-            output_schema=output_schema,
+            result_schema=result_schema,
         )
 
     def _set_args_schema(self) -> None:
@@ -601,9 +601,9 @@ def from_langchain(cls, tool: Any) -> Tool[..., Any]:
             raise ValueError("The provided tool must have a callable 'func' attribute.")
 
         args_schema = getattr(tool, "args_schema", None)
-        output_schema = getattr(tool, "output_schema", None)
-        if output_schema is None:
-            output_schema = _infer_output_schema_from_callable(tool.func)
+        result_schema = getattr(tool, "result_schema", None)
+        if result_schema is None:
+            result_schema = _infer_result_schema_from_callable(tool.func)
 
         if args_schema is None:
             func_signature = signature(tool.func)
@@ -634,7 +634,7 @@ def from_langchain(cls, tool: Any) -> Tool[..., Any]:
             description=getattr(tool, "description", ""),
             func=tool.func,
             args_schema=args_schema,
-            output_schema=output_schema,
+            result_schema=result_schema,
         )
 
 
@@ -658,7 +658,7 @@ def tool(
     name: str,
     /,
     *,
-    output_schema: type[BaseModel] | None = ...,
+    result_schema: type[BaseModel] | None = ...,
     result_as_answer: bool = ...,
     max_usage_count: int | None = ...,
 ) -> Callable[[Callable[P2, R2]], Tool[P2, R2]]: ...
@@ -667,15 +667,15 @@ def tool(
 @overload
 def tool(
     *,
-    output_schema: type[BaseModel] | None = ...,
+    result_schema: type[BaseModel] | None = ...,
     result_as_answer: bool = ...,
     max_usage_count: int | None = ...,
 ) -> Callable[[Callable[P2, R2]], Tool[P2, R2]]: ...
 
 
 def tool(
     *args: Callable[P2, R2] | str,
-    output_schema: type[BaseModel] | None = None,
+    result_schema: type[BaseModel] | None = None,
     result_as_answer: bool = False,
     max_usage_count: int | None = None,
 ) -> Tool[P2, R2] | Callable[[Callable[P2, R2]], Tool[P2, R2]]:
@@ -689,7 +689,7 @@ def tool(
     Args:
         *args: Either the function to decorate or a custom tool name.
         result_as_answer: If True, the tool result becomes the final agent answer.
-        output_schema: Optional schema for the output that the tool returns.
+        result_schema: Optional schema for the output that the tool returns.
         max_usage_count: Maximum times this tool can be used. None means unlimited.
 
     Returns:
@@ -731,16 +731,16 @@ def _make_tool(f: Callable[P2, R2]) -> Tool[P2, R2]:
 
             class_name = "".join(tool_name.split()).title()
             args_schema = create_model(class_name, **fields)
-            resolved_output_schema = (
-                output_schema or _infer_output_schema_from_callable(f)
+            resolved_result_schema = (
+                result_schema or _infer_result_schema_from_callable(f)
             )
 
             return Tool(
                 name=tool_name,
                 description=f.__doc__,
                 func=f,
                 args_schema=args_schema,
-                output_schema=resolved_output_schema,
+                result_schema=resolved_result_schema,
                 result_as_answer=result_as_answer,
                 max_usage_count=max_usage_count,
                 current_usage_count=0,

lib/crewai/src/crewai/tools/base_tool.py

@@ -37,7 +37,7 @@ def _deserialize_schema(v: Any) -> type[BaseModel] | None:
     return None
 
 
-def _infer_output_schema_from_callable(
+def _infer_result_schema_from_callable(
     func: Callable[..., Any],
 ) -> type[BaseModel] | None:
     try:
@@ -56,25 +56,25 @@ def _format_tool_output_for_agent(tool: Any, raw_result: Any) -> str:
     if original_tool is not None:
         return cast(str, original_tool.format_output_for_agent(raw_result))
 
-    output_schema = getattr(tool, "output_schema", None)
-    if not (isinstance(output_schema, type) and issubclass(output_schema, BaseModel)):
+    result_schema = getattr(tool, "result_schema", None)
+    if not (isinstance(result_schema, type) and issubclass(result_schema, BaseModel)):
         return str(raw_result)
 
     try:
         validation_input = raw_result
         if isinstance(raw_result, BaseModel) and not isinstance(
-            raw_result, output_schema
+            raw_result, result_schema
         ):
             validation_input = raw_result.model_dump()
 
-        validated = output_schema.model_validate(validation_input)
+        validated = result_schema.model_validate(validation_input)
         return validated.model_dump_json()
     except Exception as exc:
         warnings.warn(
             (
                 f"Failed to validate or serialize output from tool "
-                f"'{getattr(tool, 'name', '<unknown>')}' using output_schema "
-                f"'{output_schema.__name__}': {exc.__class__.__name__}. "
+                f"'{getattr(tool, 'name', '<unknown>')}' using result_schema "
+                f"'{result_schema.__name__}': {exc.__class__.__name__}. "
                 "Falling back to str(raw_result)."
             ),
             RuntimeWarning,
@@ -128,7 +128,7 @@ class CrewStructuredTool(BaseModel):
         BeforeValidator(_deserialize_schema),
         PlainSerializer(_serialize_schema),
     ] = Field(default=None)
-    output_schema: Annotated[
+    result_schema: Annotated[
         type[BaseModel] | None,
         BeforeValidator(_deserialize_schema),
         PlainSerializer(_serialize_schema),
@@ -155,7 +155,7 @@ def from_function(
         description: str | None = None,
         return_direct: bool = False,
         args_schema: type[BaseModel] | None = None,
-        output_schema: type[BaseModel] | None = None,
+        result_schema: type[BaseModel] | None = None,
         infer_schema: bool = True,
         **kwargs: Any,
     ) -> CrewStructuredTool:
@@ -167,7 +167,7 @@ def from_function(
             description: The description of the tool. Defaults to the function docstring
             return_direct: Whether to return the output directly
             args_schema: Optional schema for the function arguments
-            output_schema: Optional schema for the function output
+            result_schema: Optional schema for the function output
             infer_schema: Whether to infer the schema from the function signature
             **kwargs: Additional arguments to pass to the tool
 
@@ -203,7 +203,7 @@ def from_function(
             name=name,
             description=description,
             args_schema=schema,
-            output_schema=output_schema or _infer_output_schema_from_callable(func),
+            result_schema=result_schema or _infer_result_schema_from_callable(func),
             func=func,
             result_as_answer=return_direct,
             **kwargs,