feat: add binary streaming support for large file downloads

This change enables CrewAI platform tools to handle binary file responses
from the OAuth service, allowing agents to work with large files (Excel,
Word, PDF, etc.) without memory issues

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

@@ -1,12 +1,17 @@
 from datetime import datetime
+import json
 import os
 import time
-from typing import Any, ClassVar
+from typing import Annotated, Any, ClassVar, Literal
 
 from crewai.tools import BaseTool, EnvVar
+from dotenv import load_dotenv
 from pydantic import BaseModel, Field
+from pydantic.types import StringConstraints
 import requests
 
+load_dotenv()
+
 
 def _save_results_to_file(content: str) -> None:
     """Saves the search results to a file."""
@@ -15,37 +20,72 @@ def _save_results_to_file(content: str) -> None:
         file.write(content)
 
 
-class BraveSearchToolSchema(BaseModel):
-    """Input for BraveSearchTool."""
+FreshnessPreset = Literal["pd", "pw", "pm", "py"]
+FreshnessRange = Annotated[
+    str, StringConstraints(pattern=r"^\d{4}-\d{2}-\d{2}to\d{4}-\d{2}-\d{2}$")
+]
+Freshness = FreshnessPreset | FreshnessRange
+SafeSearch = Literal["off", "moderate", "strict"]
 
-    search_query: str = Field(
-        ..., description="Mandatory search query you want to use to search the internet"
+
+class BraveSearchToolSchema(BaseModel):
+    """Input for BraveSearchTool"""
+
+    query: str = Field(..., description="Search query to perform")
+    country: str | None = Field(
+        default=None,
+        description="Country code for geo-targeting (e.g., 'US', 'BR').",
+    )
+    search_language: str | None = Field(
+        default=None,
+        description="Language code for the search results (e.g., 'en', 'es').",
+    )
+    count: int | None = Field(
+        default=None,
+        description="The maximum number of results to return. Actual number may be less.",
+    )
+    offset: int | None = Field(
+        default=None, description="Skip the first N result sets/pages. Max is 9."
+    )
+    safesearch: SafeSearch | None = Field(
+        default=None,
+        description="Filter out explicit content. Options: off/moderate/strict",
+    )
+    spellcheck: bool | None = Field(
+        default=None,
+        description="Attempt to correct spelling errors in the search query.",
+    )
+    freshness: Freshness | None = Field(
+        default=None,
+        description="Enforce freshness of results. Options: pd/pw/pm/py, or YYYY-MM-DDtoYYYY-MM-DD",
+    )
+    text_decorations: bool | None = Field(
+        default=None,
+        description="Include markup to highlight search terms in the results.",
+    )
+    extra_snippets: bool | None = Field(
+        default=None,
+        description="Include up to 5 text snippets for each page if possible.",
+    )
+    operators: bool | None = Field(
+        default=None,
+        description="Whether to apply search operators (e.g., site:example.com).",
     )
 
 
+# TODO: Extend support to additional endpoints (e.g., /images, /news, etc.)
 class BraveSearchTool(BaseTool):
-    """BraveSearchTool - A tool for performing web searches using the Brave Search API.
+    """A tool that performs web searches using the Brave Search API."""
 
-    This module provides functionality to search the internet using Brave's Search API,
-    supporting customizable result counts and country-specific searches.
-
-    Dependencies:
-        - requests
-        - pydantic
-        - python-dotenv (for API key management)
-    """
-
-    name: str = "Brave Web Search the internet"
+    name: str = "Brave Search"
     description: str = (
-        "A tool that can be used to search the internet with a search_query."
+        "A tool that performs web searches using the Brave Search API. "
+        "Results are returned as structured JSON data."
     )
     args_schema: type[BaseModel] = BraveSearchToolSchema
     search_url: str = "https://api.search.brave.com/res/v1/web/search"
-    country: str | None = ""
     n_results: int = 10
     save_file: bool = False
-    _last_request_time: ClassVar[float] = 0
-    _min_request_interval: ClassVar[float] = 1.0  # seconds
     env_vars: list[EnvVar] = Field(
         default_factory=lambda: [
             EnvVar(
@@ -55,6 +95,9 @@ class BraveSearchTool(BaseTool):
             ),
         ]
     )
+    # Rate limiting parameters
+    _last_request_time: ClassVar[float] = 0
+    _min_request_interval: ClassVar[float] = 1.0  # seconds
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -73,19 +116,64 @@ class BraveSearchTool(BaseTool):
                 self._min_request_interval - (current_time - self._last_request_time)
             )
         BraveSearchTool._last_request_time = time.time()
+
+        # Construct and send the request
         try:
-            search_query = kwargs.get("search_query") or kwargs.get("query")
-            if not search_query:
-                raise ValueError("Search query is required")
+            # Maintain both "search_query" and "query" for backwards compatibility
+            query = kwargs.get("search_query") or kwargs.get("query")
+            if not query:
+                raise ValueError("Query is required")
+
+            payload = {"q": query}
+
+            if country := kwargs.get("country"):
+                payload["country"] = country
+
+            if search_language := kwargs.get("search_language"):
+                payload["search_language"] = search_language
+
+            # Fallback to deprecated n_results parameter if no count is provided
+            count = kwargs.get("count")
+            if count is not None:
+                payload["count"] = count
+            else:
+                payload["count"] = self.n_results
+
+            # Offset may be 0, so avoid truthiness check
+            offset = kwargs.get("offset")
+            if offset is not None:
+                payload["offset"] = offset
+
+            if safesearch := kwargs.get("safesearch"):
+                payload["safesearch"] = safesearch
 
             save_file = kwargs.get("save_file", self.save_file)
-            n_results = kwargs.get("n_results", self.n_results)
+            if freshness := kwargs.get("freshness"):
+                payload["freshness"] = freshness
 
-            payload = {"q": search_query, "count": n_results}
+            # Boolean parameters
+            spellcheck = kwargs.get("spellcheck")
+            if spellcheck is not None:
+                payload["spellcheck"] = spellcheck
 
-            if self.country != "":
-                payload["country"] = self.country
+            text_decorations = kwargs.get("text_decorations")
+            if text_decorations is not None:
+                payload["text_decorations"] = text_decorations
 
+            extra_snippets = kwargs.get("extra_snippets")
+            if extra_snippets is not None:
+                payload["extra_snippets"] = extra_snippets
+
+            operators = kwargs.get("operators")
+            if operators is not None:
+                payload["operators"] = operators
+
+            # Limit the result types to "web" since there is presently no
+            # handling of other types like "discussions", "faq", "infobox",
+            # "news", "videos", or "locations".
+            payload["result_filter"] = "web"
+
+            # Setup Request Headers
             headers = {
                 "X-Subscription-Token": os.environ["BRAVE_API_KEY"],
                 "Accept": "application/json",
@@ -97,25 +185,32 @@ class BraveSearchTool(BaseTool):
             response.raise_for_status()  # Handle non-200 responses
             results = response.json()
 
+            # TODO: Handle other result types like "discussions", "faq", etc.
+            web_results_items = []
             if "web" in results:
-                results = results["web"]["results"]
-                string = []
-                for result in results:
-                    try:
-                        string.append(
-                            "\n".join(
-                                [
-                                    f"Title: {result['title']}",
-                                    f"Link: {result['url']}",
-                                    f"Snippet: {result['description']}",
-                                    "---",
-                                ]
-                            )
-                        )
-                    except KeyError:  # noqa: PERF203
-                        continue
+                web_results = results["web"]["results"]
 
-            content = "\n".join(string)
+                for result in web_results:
+                    url = result.get("url")
+                    title = result.get("title")
+                    # If, for whatever reason, this entry does not have a title
+                    # or url, skip it.
+                    if not url or not title:
+                        continue
+                    item = {
+                        "url": url,
+                        "title": title,
+                    }
+                    description = result.get("description")
+                    if description:
+                        item["description"] = description
+                    snippets = result.get("extra_snippets")
+                    if snippets:
+                        item["snippets"] = snippets
+
+                    web_results_items.append(item)
+
+            content = json.dumps(web_results_items)
         except requests.RequestException as e:
             return f"Error performing search: {e!s}"
         except KeyError as e:

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

@@ -13,10 +13,16 @@ from crewai_tools.tools.crewai_platform_tools.crewai_platform_tool_builder impor
 from crewai_tools.tools.crewai_platform_tools.crewai_platform_tools import (
     CrewaiPlatformTools,
 )
+from crewai_tools.tools.crewai_platform_tools.file_hook import (
+    process_file_markers,
+    register_file_processing_hook,
+)
 
 
 __all__ = [
     "CrewAIPlatformActionTool",
     "CrewaiPlatformToolBuilder",
     "CrewaiPlatformTools",
+    "process_file_markers",
+    "register_file_processing_hook",
 ]

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

@@ -2,6 +2,8 @@
 
 import json
 import os
+import re
+import tempfile
 from typing import Any
 
 from crewai.tools import BaseTool
@@ -14,6 +16,26 @@ from crewai_tools.tools.crewai_platform_tools.misc import (
     get_platform_integration_token,
 )
 
+_FILE_MARKER_PREFIX = "__CREWAI_FILE__"
+
+_MIME_TO_EXTENSION = {
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx",
+    "application/vnd.ms-excel": ".xls",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": ".docx",
+    "application/msword": ".doc",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation": ".pptx",
+    "application/vnd.ms-powerpoint": ".ppt",
+    "application/pdf": ".pdf",
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "image/gif": ".gif",
+    "image/webp": ".webp",
+    "text/plain": ".txt",
+    "text/csv": ".csv",
+    "application/json": ".json",
+    "application/zip": ".zip",
+}
+
 
 class CrewAIPlatformActionTool(BaseTool):
     action_name: str = Field(default="", description="The name of the action")
@@ -71,10 +93,18 @@ class CrewAIPlatformActionTool(BaseTool):
                 url=api_url,
                 headers=headers,
                 json=payload,
-                timeout=60,
+                timeout=300,
+                stream=True,
                 verify=os.environ.get("CREWAI_FACTORY", "false").lower() != "true",
             )
 
+            content_type = response.headers.get("Content-Type", "")
+
+            # Check if response is binary (non-JSON)
+            if "application/json" not in content_type:
+                return self._handle_binary_response(response)
+
+            # Normal JSON response
             data = response.json()
             if not response.ok:
                 if isinstance(data, dict):
@@ -91,3 +121,49 @@ class CrewAIPlatformActionTool(BaseTool):
 
         except Exception as e:
             return f"Error executing action {self.action_name}: {e!s}"
+
+    def _handle_binary_response(self, response: requests.Response) -> str:
+        """Handle binary streaming response from the API.
+
+        Streams the binary content to a temporary file and returns a marker
+        that can be processed by the file hook to inject the file into the
+        LLM context.
+
+        Args:
+            response: The streaming HTTP response with binary content.
+
+        Returns:
+            A file marker string in the format:
+            __CREWAI_FILE__:filename:content_type:file_path
+        """
+        content_type = response.headers.get("Content-Type", "application/octet-stream")
+
+        filename = self._extract_filename_from_headers(response.headers)
+
+        extension = self._get_file_extension(content_type, filename)
+
+        with tempfile.NamedTemporaryFile(
+            delete=False, suffix=extension, prefix="crewai_"
+        ) as tmp_file:
+            for chunk in response.iter_content(chunk_size=8192):
+                tmp_file.write(chunk)
+            tmp_path = tmp_file.name
+
+        return f"{_FILE_MARKER_PREFIX}:{filename}:{content_type}:{tmp_path}"
+
+    def _extract_filename_from_headers(
+        self, headers: requests.structures.CaseInsensitiveDict
+    ) -> str:
+        content_disposition = headers.get("Content-Disposition", "")
+        if content_disposition:
+            match = re.search(r'filename="?([^";\s]+)"?', content_disposition)
+            if match:
+                return match.group(1)
+        return "downloaded_file"
+
+    def _get_file_extension(self, content_type: str, filename: str) -> str:
+        if "." in filename:
+            return "." + filename.rsplit(".", 1)[-1]
+
+        base_content_type = content_type.split(";")[0].strip()
+        return _MIME_TO_EXTENSION.get(base_content_type, "")

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

@@ -6,6 +6,9 @@ from crewai_tools.adapters.tool_collection import ToolCollection
 from crewai_tools.tools.crewai_platform_tools.crewai_platform_tool_builder import (
     CrewaiPlatformToolBuilder,
 )
+from crewai_tools.tools.crewai_platform_tools.file_hook import (
+    register_file_processing_hook,
+)
 
 
 logger = logging.getLogger(__name__)
@@ -22,6 +25,8 @@ def CrewaiPlatformTools(  # noqa: N802
     Returns:
         A list of BaseTool instances for platform actions
     """
+    register_file_processing_hook()
+
     builder = CrewaiPlatformToolBuilder(apps=apps)
 
     return builder.tools()  # type: ignore

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

@@ -0,0 +1,132 @@
+"""File processing hook for CrewAI Platform Tools.
+
+This module provides a hook that processes file markers returned by platform tools
+and injects the files into the LLM context for native file handling.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from crewai.hooks.tool_hooks import ToolCallHookContext
+
+logger = logging.getLogger(__name__)
+
+_FILE_MARKER_PREFIX = "__CREWAI_FILE__"
+
+_hook_registered = False
+
+
+def process_file_markers(context: ToolCallHookContext) -> str | None:
+    """Process file markers in tool results and inject files into context.
+
+    This hook detects file markers returned by platform tools (e.g., download_file)
+    and converts them into FileInput objects that are attached to the hook context.
+    The agent executor will then inject these files into the tool message for
+    native LLM file handling.
+
+    The marker format is:
+        __CREWAI_FILE__:filename:content_type:file_path
+
+    Args:
+        context: The tool call hook context containing the tool result.
+
+    Returns:
+        A human-readable message if a file was processed, None otherwise.
+    """
+    result = context.tool_result
+
+    if not result or not result.startswith(_FILE_MARKER_PREFIX):
+        return None
+
+    try:
+        parts = result.split(":", 3)
+        if len(parts) < 4:
+            logger.warning(f"Invalid file marker format: {result[:100]}")
+            return None
+
+        _, filename, content_type, file_path = parts
+
+        if not os.path.isfile(file_path):
+            logger.error(f"File not found: {file_path}")
+            return f"Error: Downloaded file not found at {file_path}"
+
+        try:
+            from crewai_files import File
+        except ImportError:
+            logger.warning(
+                "crewai_files not installed. File will not be attached to LLM context."
+            )
+            return (
+                f"Downloaded file: {filename} ({content_type}). "
+                f"File saved at: {file_path}. "
+                "Note: Install crewai_files for native LLM file handling."
+            )
+
+        file = File(source=file_path, content_type=content_type, filename=filename)
+
+        context.files = {filename: file}
+
+        file_size = os.path.getsize(file_path)
+        size_str = _format_file_size(file_size)
+
+        return f"Downloaded file: {filename} ({content_type}, {size_str}). File is attached for LLM analysis."
+
+    except Exception as e:
+        logger.exception(f"Error processing file marker: {e}")
+        return f"Error processing downloaded file: {e}"
+
+
+def _format_file_size(size_bytes: int) -> str:
+    """Format file size in human-readable format.
+
+    Args:
+        size_bytes: Size in bytes.
+
+    Returns:
+        Human-readable size string.
+    """
+    if size_bytes < 1024:
+        return f"{size_bytes} bytes"
+    elif size_bytes < 1024 * 1024:
+        return f"{size_bytes / 1024:.1f} KB"
+    elif size_bytes < 1024 * 1024 * 1024:
+        return f"{size_bytes / (1024 * 1024):.1f} MB"
+    else:
+        return f"{size_bytes / (1024 * 1024 * 1024):.1f} GB"
+
+
+def register_file_processing_hook() -> bool:
+    """Register the file processing hook globally.
+
+    This function should be called once during application initialization
+    to enable automatic file injection for platform tools.
+
+    Returns:
+        True if the hook was registered, False if it was already registered
+        or if registration failed.
+    """
+    global _hook_registered
+
+    if _hook_registered:
+        logger.debug("File processing hook already registered")
+        return False
+
+    try:
+        from crewai.hooks import register_after_tool_call_hook
+
+        register_after_tool_call_hook(process_file_markers)
+        _hook_registered = True
+        logger.info("File processing hook registered successfully")
+        return True
+    except ImportError:
+        logger.warning(
+            "crewai.hooks not available. File processing hook not registered."
+        )
+        return False
+    except Exception as e:
+        logger.exception(f"Failed to register file processing hook: {e}")
+        return False

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

@@ -1,8 +1,10 @@
+import json
 from unittest.mock import patch
 
-from crewai_tools.tools.brave_search_tool.brave_search_tool import BraveSearchTool
 import pytest
 
+from crewai_tools.tools.brave_search_tool.brave_search_tool import BraveSearchTool
+
 
 @pytest.fixture
 def brave_tool():
@@ -30,16 +32,43 @@ def test_brave_tool_search(mock_get, brave_tool):
     }
     mock_get.return_value.json.return_value = mock_response
 
-    result = brave_tool.run(search_query="test")
+    result = brave_tool.run(query="test")
     assert "Test Title" in result
     assert "http://test.com" in result
 
 
-def test_brave_tool():
-    tool = BraveSearchTool(
-        n_results=2,
-    )
-    tool.run(search_query="ChatGPT")
+@patch("requests.get")
+def test_brave_tool(mock_get):
+    mock_response = {
+        "web": {
+            "results": [
+                {
+                    "title": "Brave Browser",
+                    "url": "https://brave.com",
+                    "description": "Brave Browser description",
+                }
+            ]
+        }
+    }
+    mock_get.return_value.json.return_value = mock_response
+
+    tool = BraveSearchTool(n_results=2)
+    result = tool.run(query="Brave Browser")
+    assert result is not None
+
+    # Parse JSON so we can examine the structure
+    data = json.loads(result)
+    assert isinstance(data, list)
+    assert len(data) >= 1
+
+    # First item should have expected fields: title, url, and description
+    first = data[0]
+    assert "title" in first
+    assert first["title"] == "Brave Browser"
+    assert "url" in first
+    assert first["url"] == "https://brave.com"
+    assert "description" in first
+    assert first["description"] == "Brave Browser description"
 
 
 if __name__ == "__main__":

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

@@ -2,6 +2,7 @@ import unittest
 from unittest.mock import Mock, patch
 
 from crewai_tools.tools.crewai_platform_tools import CrewaiPlatformTools
+from crewai_tools.tools.crewai_platform_tools import file_hook
 
 
 class TestCrewaiPlatformTools(unittest.TestCase):
@@ -113,3 +114,64 @@ class TestCrewaiPlatformTools(unittest.TestCase):
             with self.assertRaises(ValueError) as context:
                 CrewaiPlatformTools(apps=["github"])
             assert "No platform integration token found" in str(context.exception)
+
+    @patch.dict("os.environ", {"CREWAI_PLATFORM_INTEGRATION_TOKEN": "test_token"})
+    @patch(
+        "crewai_tools.tools.crewai_platform_tools.crewai_platform_tool_builder.requests.get"
+    )
+    @patch(
+        "crewai_tools.tools.crewai_platform_tools.crewai_platform_tools.register_file_processing_hook"
+    )
+    def test_crewai_platform_tools_registers_file_hook(
+        self, mock_register_hook, mock_get
+    ):
+        mock_response = Mock()
+        mock_response.raise_for_status.return_value = None
+        mock_response.json.return_value = {"actions": {"github": []}}
+        mock_get.return_value = mock_response
+
+        CrewaiPlatformTools(apps=["github"])
+        mock_register_hook.assert_called_once()
+
+
+class TestFileHook(unittest.TestCase):
+    def setUp(self):
+        file_hook._hook_registered = False
+
+    def tearDown(self):
+        file_hook._hook_registered = False
+
+    @patch("crewai.hooks.register_after_tool_call_hook")
+    def test_register_hook_is_idempotent(self, mock_register):
+        """Test hook registration succeeds once and is idempotent."""
+        assert file_hook.register_file_processing_hook() is True
+        assert file_hook._hook_registered is True
+        mock_register.assert_called_once_with(file_hook.process_file_markers)
+
+        # Second call should return False and not register again
+        assert file_hook.register_file_processing_hook() is False
+        mock_register.assert_called_once()
+
+    def test_process_file_markers_ignores_non_file_results(self):
+        """Test that non-file-marker results return None."""
+        test_cases = [
+            None,  # Empty result
+            "Regular tool output",  # Non-marker
+            "__CREWAI_FILE__:incomplete",  # Invalid format (missing parts)
+        ]
+        for tool_result in test_cases:
+            mock_context = Mock()
+            mock_context.tool_result = tool_result
+            assert file_hook.process_file_markers(mock_context) is None
+
+    def test_format_file_size(self):
+        """Test file size formatting across units."""
+        cases = [
+            (500, "500 bytes"),
+            (1024, "1.0 KB"),
+            (1536, "1.5 KB"),
+            (1024 * 1024, "1.0 MB"),
+            (1024 * 1024 * 1024, "1.0 GB"),
+        ]
+        for size_bytes, expected in cases:
+            assert file_hook._format_file_size(size_bytes) == expected

lib/crewai/src/crewai/agents/agent_adapters/openai_agents/openai_agent_tool_adapter.py

@@ -16,6 +16,7 @@ from crewai.agents.agent_adapters.openai_agents.protocols import (
 )
 from crewai.tools import BaseTool
 from crewai.utilities.import_utils import require
+from crewai.utilities.pydantic_schema_utils import force_additional_properties_false
 from crewai.utilities.string_utils import sanitize_tool_name
 
 
@@ -135,7 +136,9 @@ class OpenAIAgentToolAdapter(BaseToolAdapter):
         for tool in tools:
             schema: dict[str, Any] = tool.args_schema.model_json_schema()
 
-            schema.update({"additionalProperties": False, "type": "object"})
+            schema = force_additional_properties_false(schema)
+
+            schema.update({"type": "object"})
 
             openai_tool: OpenAIFunctionTool = cast(
                 OpenAIFunctionTool,

lib/crewai/src/crewai/agents/crew_agent_executor.py

@@ -930,6 +930,10 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
             "name": func_name,
             "content": result,
         }
+
+        if after_hook_context.files:
+            tool_message["files"] = after_hook_context.files
+
         self.messages.append(tool_message)
 
         # Log the tool execution

lib/crewai/src/crewai/experimental/agent_executor.py

@@ -814,6 +814,10 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
                 "name": func_name,
                 "content": result,
             }
+
+            if after_hook_context.files:
+                tool_message["files"] = after_hook_context.files
+
             self.state.messages.append(tool_message)
 
             # Log the tool execution

lib/crewai/src/crewai/hooks/tool_hooks.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Any
 from crewai.events.event_listener import event_listener
 from crewai.hooks.types import AfterToolCallHookType, BeforeToolCallHookType
 from crewai.utilities.printer import Printer
+from crewai.utilities.types import FileInput
 
 
 if TYPE_CHECKING:
@@ -34,6 +35,9 @@ class ToolCallHookContext:
         crew: Crew instance (may be None)
         tool_result: Tool execution result (only set for after_tool_call hooks).
             Can be modified by returning a new string from after_tool_call hook.
+        files: Optional dictionary of files to attach to the tool message.
+            Can be set by after_tool_call hooks to inject files into the LLM context.
+            These files will be formatted according to the LLM provider's requirements.
     """
 
     def __init__(
@@ -64,6 +68,7 @@ class ToolCallHookContext:
         self.task = task
         self.crew = crew
         self.tool_result = tool_result
+        self.files: dict[str, FileInput] | None = None
 
     def request_human_input(
         self,

lib/crewai/src/crewai/llms/providers/openai/completion.py

@@ -1521,13 +1521,16 @@ class OpenAICompletion(BaseLLM):
     ) -> list[dict[str, Any]]:
         """Convert CrewAI tool format to OpenAI function calling format."""
         from crewai.llms.providers.utils.common import safe_tool_conversion
+        from crewai.utilities.pydantic_schema_utils import (
+            force_additional_properties_false,
+        )
 
         openai_tools = []
 
         for tool in tools:
             name, description, parameters = safe_tool_conversion(tool, "OpenAI")
 
-            openai_tool = {
+            openai_tool: dict[str, Any] = {
                 "type": "function",
                 "function": {
                     "name": name,
@@ -1537,10 +1540,11 @@ class OpenAICompletion(BaseLLM):
             }
 
             if parameters:
-                if isinstance(parameters, dict):
-                    openai_tool["function"]["parameters"] = parameters  # type: ignore
-                else:
-                    openai_tool["function"]["parameters"] = dict(parameters)
+                params_dict = (
+                    parameters if isinstance(parameters, dict) else dict(parameters)
+                )
+                params_dict = force_additional_properties_false(params_dict)
+                openai_tool["function"]["parameters"] = params_dict
 
             openai_tools.append(openai_tool)
         return openai_tools

lib/crewai/src/crewai/utilities/pydantic_schema_utils.py

@@ -127,6 +127,36 @@ def add_key_in_dict_recursively(
     return d
 
 
+def force_additional_properties_false(d: Any) -> Any:
+    """Force additionalProperties=false on all object-type dicts recursively.
+
+    OpenAI strict mode requires all objects to have additionalProperties=false.
+    This function overwrites any existing value to ensure compliance.
+
+    Also ensures objects have properties and required arrays, even if empty,
+    as OpenAI strict mode requires these for all object types.
+
+    Args:
+        d: The dictionary/list to modify.
+
+    Returns:
+        The modified dictionary/list.
+    """
+    if isinstance(d, dict):
+        if d.get("type") == "object":
+            d["additionalProperties"] = False
+            if "properties" not in d:
+                d["properties"] = {}
+            if "required" not in d:
+                d["required"] = []
+        for v in d.values():
+            force_additional_properties_false(v)
+    elif isinstance(d, list):
+        for i in d:
+            force_additional_properties_false(i)
+    return d
+
+
 def fix_discriminator_mappings(schema: dict[str, Any]) -> dict[str, Any]:
     """Replace '#/$defs/...' references in discriminator.mapping with just the model name.
 
@@ -278,13 +308,7 @@ def generate_model_description(model: type[BaseModel]) -> dict[str, Any]:
     """
     json_schema = model.model_json_schema(ref_template="#/$defs/{model}")
 
-    json_schema = add_key_in_dict_recursively(
-        json_schema,
-        key="additionalProperties",
-        value=False,
-        criteria=lambda d: d.get("type") == "object"
-        and "additionalProperties" not in d,
-    )
+    json_schema = force_additional_properties_false(json_schema)
 
     json_schema = resolve_refs(json_schema)
 
@@ -378,6 +402,9 @@ def create_model_from_schema(  # type: ignore[no-any-unimported]
     """
     effective_root = root_schema or json_schema
 
+    json_schema = force_additional_properties_false(json_schema)
+    effective_root = force_additional_properties_false(effective_root)
+
     if "allOf" in json_schema:
         json_schema = _merge_all_of_schemas(json_schema["allOf"], effective_root)
         if "title" not in json_schema and "title" in (root_schema or {}):