```diff
--- test_files/342-original.txt	2025-03-07 19:06:48
+++ test_files/342-modified.txt	2025-03-07 19:06:48
@@ -2,23 +2,29 @@
 
 from pydantic import Field
 
-from composio.tools.env.filemanager.manager import FileManager
+from composio.tools.base.local import LocalAction
 from composio.tools.local.filetool.actions.base_action import (
-    BaseFileAction,
     BaseFileRequest,
     BaseFileResponse,
+    include_cwd,
 )
 
 
 class FindFileRequest(BaseFileRequest):
     """Request to find files matching a pattern."""
 
-    pattern: str = Field(..., description="Pattern to search for (supports wildcards)")
+    pattern: str = Field(
+        ...,
+        description="Pattern to search for (supports wildcards)",
+    )
     depth: t.Optional[int] = Field(
-        default=None, description="Max depth to search for (None for unlimited)", ge=0
+        default=None,
+        description="Max depth to search for (None for unlimited)",
+        ge=0,
     )
     case_sensitive: bool = Field(
-        default=False, description="If set True the search will be case sensitive"
+        default=False,
+        description="If set True the search will be case sensitive",
     )
     include: t.List[str] = Field(
         default=None,
@@ -34,12 +40,20 @@
     """Response to find files matching a pattern."""
 
     results: t.List[str] = Field(
-        default=[], description="List of file paths matching the search pattern"
+        default=[],
+        description="List of file paths matching the search pattern",
     )
-    error: str = Field(default="", description="Error message if any")
+    message: str = Field(
+        default="",
+        description="Message to display to the user",
+    )
+    error: str = Field(
+        default="",
+        description="Error message if any",
+    )
 
 
-class FindFile(BaseFileAction):
+class FindFile(LocalAction[FindFileRequest, FindFileResponse]):
     """
     Finds files or directories matching the given pattern in the workspace.
 
@@ -51,43 +65,38 @@
     match the given pattern.
 
     Usage examples:
-    1. Find all Python files:
-       pattern: "*.py"
-    2. Find all text files starting with "test_":
-       pattern: "test_*.txt"
-    3. Find all Markdown files in any subdirectory:
-       pattern: "**/*.md"
-    4. Find CSV files with names like "data001.csv", "data002.csv", etc.:
-       pattern: "data???.csv"
-    5. Find all "main.js" files in the "src" directory and its subdirectories:
-       pattern: "src/**/main.js"
+    1. All Python files: "*.py"
+    2. Text files starting with "test_": "test_*.txt"
+    3. Markdown files in any subdirectory: "**/*.md"
+    4. CSV files like "data001.csv", "data002.csv": "data???.csv"
+    5. "main.js" in "src" and subdirs: "src/**/main.js"
 
     Note: The search automatically excludes the '.git' directory.
 
     Returns:
-    - A list of file paths (as strings) relative to the working directory that match the search pattern.
-
-    Raises:
-    - ValueError: If the pattern is empty or invalid.
-    - PermissionError: If there's no permission to access certain directories.
-    - OSError: If there's an issue with the file system operations.
+    - A list of file paths relative to the working directory that match the search pattern.
     """
 
-    _display_name = "Find Files"
-    _request_schema = FindFileRequest
-    _response_schema = FindFileResponse
-
-    def execute_on_file_manager(
-        self, file_manager: FileManager, request_data: FindFileRequest  # type: ignore
-    ) -> FindFileResponse:
+    @include_cwd  # type: ignore
+    def execute(self, request: FindFileRequest, metadata: t.Dict) -> FindFileResponse:
         try:
-            results = file_manager.find(
-                pattern=request_data.pattern,
-                depth=request_data.depth,
-                case_sensitive=request_data.case_sensitive,
-                include=request_data.include,  # type: ignore
-                exclude=request_data.exclude,  # type: ignore
+            results = self.filemanagers.get(request.file_manager_id).find(
+                pattern=request.pattern,
+                depth=request.depth,
+                case_sensitive=request.case_sensitive,
+                include=request.include,  # type: ignore
+                exclude=request.exclude,  # type: ignore
             )
+            if len(results) > 200:
+                return FindFileResponse(
+                    results=results[:200],
+                    message=(
+                        f"Too many results found. Found {len(results)} results, "
+                        "returning 300 of them. Please refine your search criteria."
+                    ),
+                )
+            if results == []:
+                return FindFileResponse(error="No results found.")
             return FindFileResponse(results=results)
         except ValueError as e:
             return FindFileResponse(error=f"Invalid search parameters: {str(e)}")
```
