feat: Implement lockfiles for composio toolset

python/composio/client/collections.py

@@ -1027,6 +1027,7 @@ class ActionModel(BaseModel):
 
     name: str
     display_name: t.Optional[str] = None
+    version: str
     parameters: ActionParametersModel
     response: ActionResponseModel
     appName: str

python/composio/constants.py

@@ -98,3 +98,8 @@
 """
 Name of the pusher cluster.
 """
+
+LOCKFILE_PATH = Path("./.composio.lock")
+"""
+Path to the .composio.lock file.
+"""

python/composio/tools/base/abs.py

@@ -340,6 +340,8 @@ def _generate_schema(cls) -> None:
         cls._schema = {
             "name": cls.name,
             "enum": cls.enum,
+            # TODO: get version from api
+            "version": "0_1",
             "appName": cls.tool,
             "appId": generate_app_id(cls.tool),
             "tags": cls.tags(),

python/composio/tools/local/handler.py

@@ -55,6 +55,8 @@ def get_action_schemas(
 
         for schema in action_schemas:
             schema["name"] = schema["enum"]
+            # TODO: Put version in local tool schemas
+            schema["version"] = "0_1"
 
         return action_schemas
 

python/composio/tools/toolset.py

@@ -18,6 +18,7 @@
 from pathlib import Path
 
 import typing_extensions as te
+import yaml
 from pydantic import BaseModel
 
 from composio import Action, ActionType, App, AppType, TagType
@@ -51,6 +52,7 @@
     LOCAL_CACHE_DIRECTORY,
     LOCAL_OUTPUT_FILE_DIRECTORY_NAME,
     USER_DATA_FILE_NAME,
+    LOCKFILE_PATH,
 )
 from composio.exceptions import ApiKeyNotProvidedError, ComposioSDKError
 from composio.storage.user import UserData
@@ -198,6 +200,7 @@ def __init__(
         connected_account_ids: t.Optional[t.Dict[AppType, str]] = None,
         *,
         max_retries: int = 3,
+        lock: bool = True,
         **kwargs: t.Any,
     ) -> None:
         """
@@ -330,6 +333,13 @@ def _limit_file_search_response(response: t.Dict) -> t.Dict:
         # composio_openai's Toolset.
         self._requested_actions: t.List[str] = []
 
+        if lock:
+            self.locking_enabled = True
+            self._tool_versions = self.load_tool_versions_from_lockfile()
+        else:
+            self.locking_enabled = False
+            self._tool_versions = {}
+
     def _validating_connection_ids(
         self,
         connected_account_ids: t.Dict[AppType, str],
@@ -1019,6 +1029,7 @@ def get_action_schemas(
         *,
         check_connected_accounts: bool = True,
         _populate_requested: bool = False,
+        # TODO: take manual override version as parameter
     ) -> t.List[ActionModel]:
         runtime_actions = t.cast(
             t.List[t.Type[LocalAction]],
@@ -1054,6 +1065,7 @@ def get_action_schemas(
                 apps=remote_apps,
                 actions=remote_actions,
                 tags=tags,
+                # TODO: use tool version when fetching actions
             )
             if check_connected_accounts:
                 for item in remote_items:
@@ -1088,6 +1100,10 @@ def get_action_schemas(
             action_names = [item.name for item in items]
             self._requested_actions += action_names
 
+        if self.locking_enabled:
+            self._tool_versions |= {tool.name: tool.version for tool in items}
+            self.store_tool_versions_to_lockfile()
+
         return items
 
     def _process_schema(self, action_item: ActionModel) -> ActionModel:
@@ -1660,6 +1676,34 @@ def _validate_auth_config(
 
         return auth_config, False
 
+    @staticmethod
+    def load_tool_versions_from_lockfile() -> t.Dict[str, str]:
+        """Load tool versions from lockfile."""
+        if not LOCKFILE_PATH.exists():
+            return {}
+
+        with open(LOCKFILE_PATH, encoding="utf-8") as file:
+            tool_versions = yaml.safe_load(file)
+
+        # Validate lockfile
+        if not isinstance(tool_versions, dict):
+            raise ComposioSDKError(
+                f"Invalid lockfile format, expected dict, got {type(tool_versions)}"
+            )
+
+        for tool in tool_versions.values():
+            if not isinstance(tool, str):
+                raise ComposioSDKError(
+                    f"Invalid lockfile format, expected version to be string, got {tool!r}"
+                )
+
+        return tool_versions
+
+    def store_tool_versions_to_lockfile(self) -> None:
+        """Store tool versions to lockfile."""
+        with open(LOCKFILE_PATH, "w", encoding="utf-8") as file:
+            yaml.safe_dump(self._tool_versions, file)
+
 
 def _write_file(file_path: t.Union[str, os.PathLike], content: t.Union[str, bytes]):
     """Write content to a file."""