```diff
--- test_files/043-original.txt	2025-03-07 19:06:15
+++ test_files/043-modified.txt	2025-03-07 19:06:15
@@ -1,20 +1,29 @@
 import logging
 import typing as t
+import warnings
 
+import typing_extensions as te
 from griptape.tools import BaseTool
 from griptape.utils.decorators import activity
 from schema import Literal, Schema
 
-from composio.client.enums import Action, App, Tag
-from composio.constants import DEFAULT_ENTITY_ID
+from composio import Action, ActionType, AppType, TagType
+from composio.exceptions import InvalidSchemaError
 from composio.tools import ComposioToolSet as BaseComposioToolSet
+from composio.tools.toolset import ProcessorsType
+from composio.utils import help_msg
 from composio.utils.shared import PYDANTIC_TYPE_TO_PYTHON_TYPE
 
 
 logger = logging.getLogger(__name__)
 
 
-class ComposioToolSet(BaseComposioToolSet):
+class ComposioToolSet(
+    BaseComposioToolSet,
+    runtime="griptape",
+    description_char_limit=1024,
+    action_name_char_limit=64,
+):
     """
     Composio toolset wrapper for Griptape framework.
 
@@ -43,36 +52,12 @@
     ```
     """
 
-    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,
-    ) -> None:
-        """
-        Initialize composio toolset.
-
-        :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="griptape",
-            entity_id=entity_id,
-            output_in_file=output_in_file,
-        )
-
     def _wrap_tool(
         self,
         schema: t.Dict,
         entity_id: t.Optional[str] = None,
     ) -> BaseTool:
         """Wrap Composio tool as GripTape `BaseTool` object"""
-        app = schema["appName"]
         name = schema["name"]
         description = schema["description"]
 
@@ -90,8 +75,9 @@
                 )
                 schema_dtype = list[schema_array_dtype] if schema_array_dtype else list  # type: ignore
             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}"
                 )
 
             schema_dict[schema_key] = schema_dtype
@@ -99,9 +85,10 @@
         def _execute_task(params: t.Dict) -> t.Dict:
             """Placeholder method for executing task."""
             return self.execute_action(
-                action=Action.from_app_and_action(app=app, name=name),
+                action=Action(value=name),
                 params=params,
                 entity_id=entity_id or self.entity_id,
+                _check_requested_actions=True,
             )
 
         class GripTapeTool(BaseTool):
@@ -134,9 +121,10 @@
         cls = type(name, (GripTapeTool,), {})
         return cls()
 
+    @te.deprecated("Use `ComposioToolSet.get_tools` instead.\n", category=None)
     def get_actions(
         self,
-        actions: t.Sequence[Action],
+        actions: t.Sequence[ActionType],
         entity_id: t.Optional[str] = None,
     ) -> t.List[BaseTool]:
         """
@@ -146,34 +134,48 @@
         :param entity_id: Entity ID to use for executing function calls.
         :return: Composio tools wrapped as `BaseTool` objects
         """
+        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._wrap_tool(
-                schema=tool.model_dump(exclude_none=True),
-                entity_id=entity_id,
-            )
-            for tool in self.get_action_schemas(actions=actions)
-        ]
-
     def get_tools(
         self,
-        apps: t.Sequence[App],
-        tags: t.Optional[t.List[t.Union[str, Tag]]] = None,
+        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[BaseTool]:
         """
         Get composio tools wrapped as GripTape `BaseTool` type objects.
 
+        :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 to use for executing function calls.
+        :param entity_id: Entity ID for the function wrapper
+
         :return: Composio tools wrapped as `BaseTool` objects
         """
-
+        self.validate_tools(apps=apps, actions=actions, tags=tags)
+        if processors is not None:
+            self._processor_helpers.merge_processors(processors)
         return [
             self._wrap_tool(
-                schema=tool.model_dump(exclude_none=True),
+                schema=tool.model_dump(
+                    exclude_none=True,
+                ),
                 entity_id=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,
+            )
         ]
```
