```diff
--- test_files/038-original.txt	2025-03-07 19:06:15
+++ test_files/038-modified.txt	2025-03-07 19:06:15
@@ -1,14 +1,17 @@
 import os
 import typing as t
+import warnings
 
-from composio.client.enums import Action, ActionType, AppType, TagType
-from composio.constants import DEFAULT_ENTITY_ID
-from composio.tools import ComposioToolSet as BaseComposioToolSet
+import typing_extensions as te
 
+from composio import Action, ActionType, AppType
+from composio import ComposioToolSet as BaseComposioToolSet
+from composio import TagType
+from composio.exceptions import InvalidSchemaError
+from composio.tools.toolset import ProcessorsType
+from composio.utils import help_msg
 
-# from composio.tools.env.factory import ExecEnv
 
-
 _openapi_to_python = {
     "string": "str",
     "number": "int",
@@ -17,50 +20,30 @@
 }
 
 
-class ComposioToolSet(BaseComposioToolSet):
+class ComposioToolSet(
+    BaseComposioToolSet,
+    runtime="praisonai",
+    description_char_limit=1024,
+    action_name_char_limit=64,
+):
     """
-    Composio toolset for Langchain framework.
+    Composio toolset for PraisonAI framework.
     """
 
-    def __init__(
-        self,
-        api_key: t.Optional[str] = None,
-        base_url: t.Optional[str] = None,
-        entity_id: str = DEFAULT_ENTITY_ID,
-        output_in_file: bool = False,
-        # workspace_env: ExecEnv = ExecEnv.DOCKER,
-        # workspace_id: t.Optional[str] = None,
-    ) -> None:
-        """
-        Initialize composio toolset.
+    _tools_file = "tools.py"
+    _imports = [
+        "import typing as t",
+        "from typing import Type",
+        "from praisonai_tools import BaseTool",
+        "from composio_praisonai import ComposioToolSet",
+        "from langchain.pydantic_v1 import BaseModel, Field",
+    ]
 
-        :param api_key: Composio API key
-        :param base_url: Base URL for the Composio API server
-        :param entity_id: Entity ID for making function calls
-        :param output_in_file: Whether to write output to a file
-        """
-        super().__init__(
-            api_key=api_key,
-            base_url=base_url,
-            runtime="praisonai",
-            entity_id=entity_id,
-            output_in_file=output_in_file,
-            # workspace_env=workspace_env,
-            # workspace_id=workspace_id,
-        )
+    def _create_tool_file(self) -> None:
+        if not os.path.exists(self._tools_file):
+            with open(self._tools_file, "w", encoding="utf-8") as tool_file:
+                tool_file.write("\n".join(self._imports) + "\n\n")
 
-        prefix_imports = [
-            "import typing as t",
-            "from typing import Type",
-            "from praisonai_tools import BaseTool",
-            "from composio_praisonai import ComposioToolSet",
-            "from langchain.pydantic_v1 import BaseModel, Field",
-        ]
-        self.tool_file_path = "tools.py"
-        if not os.path.exists(self.tool_file_path):
-            with open(self.tool_file_path, "w", encoding="utf-8") as tool_file:
-                tool_file.write("\n".join(prefix_imports) + "\n\n")
-
     def _process_input_schema(
         self,
         input_model_name: str,
@@ -82,8 +65,9 @@
                     f"list[{schema_array_dtype}]" if schema_array_dtype else "list"
                 )
             else:
-                raise TypeError(
-                    f"Some dtype of current schema are not handled yet. Current Schema: {param_body}"
+                raise InvalidSchemaError(
+                    "Some dtype of current schema are not handled yet. "
+                    f"Current Schema: {param_body}"
                 )
 
             input_model_lines.append(
@@ -97,6 +81,7 @@
             action=Action(value=tool_identifier),
             params=params,
             entity_id=self.entity_id,
+            _check_requested_actions=True,
         )
 
     def _process_basetool(
@@ -137,7 +122,7 @@
         entity_id: t.Optional[str] = None,
     ) -> str:
         """
-        Generats PraisonAI tools from Composio Actions
+        Generates PraisonAI tools from Composio Actions
 
         :param action_name: Identifier for the tool action.
         :param tool_name: Name of the tool class.
@@ -165,7 +150,10 @@
         )
 
         tool_str = input_model_str + "\n\n" + basetool_str
-        with open(self.tool_file_path, "r+", encoding="utf-8") as tool_file:
+        if not os.path.exists(self._tools_file):
+            self._create_tool_file()
+
+        with open(self._tools_file, "r+", encoding="utf-8") as tool_file:
             if tool_str not in tool_file.read():
                 tool_file.write("\n\n" + tool_str)
 
@@ -185,6 +173,7 @@
 
         return "\n".join(tools_section_parts)
 
+    @te.deprecated("Use `ComposioToolSet.get_tools` instead.\n", category=None)
     def get_actions(
         self,
         actions: t.Sequence[ActionType],
@@ -197,33 +186,46 @@
         :param entity_id: Entity ID to use for executing function calls.
         :return: Name of the tools written
         """
+        warnings.warn(
+            "Use `ComposioToolSet.get_tools` instead.\n" + help_msg(),
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.get_tools(actions=actions, entity_id=entity_id)
 
-        return [
-            self._write_tool(
-                schema=tool.model_dump(exclude_none=True),
-                entity_id=entity_id or self.entity_id,
-            )
-            for tool in self.get_action_schemas(actions=actions)
-        ]
-
     def get_tools(
         self,
-        apps: t.Sequence[AppType],
+        actions: t.Optional[t.Sequence[ActionType]] = None,
+        apps: t.Optional[t.Sequence[AppType]] = None,
         tags: t.Optional[t.List[TagType]] = None,
         entity_id: t.Optional[str] = None,
+        *,
+        processors: t.Optional[ProcessorsType] = None,
+        check_connected_accounts: bool = True,
     ) -> t.List[str]:
         """
         Get composio tools written as ParisonAi supported tools.
 
-        :param actions: List of actions to write
-        :param entity_id: Entity ID to use for executing function calls.
+        :param actions: List of actions to wrap
+        :param apps: List of apps to wrap
+        :param tags: Filter the apps by given tags
+        :param entity_id: Entity ID for the function wrapper
+
         :return: Name of the tools written
         """
-
+        self.validate_tools(apps=apps, actions=actions, tags=tags)
+        if processors is not None:
+            self._processor_helpers.merge_processors(processors)
         return [
             self._write_tool(
                 schema=tool.model_dump(exclude_none=True),
                 entity_id=entity_id or self.entity_id,
             )
-            for tool in self.get_action_schemas(apps=apps, tags=tags)
+            for tool in self.get_action_schemas(
+                actions=actions,
+                apps=apps,
+                tags=tags,
+                check_connected_accounts=check_connected_accounts,
+                _populate_requested=True,
+            )
         ]
```
