google-cloud-agentplatform 1.165.1.dev0__py3-none-any.whl

agentplatform/_genai/skills.py

@@ -0,0 +1,1708 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# Code generated by the Google Gen AI SDK generator DO NOT EDIT.
+
+import asyncio
+import base64
+import importlib
+import json
+import logging
+import typing
+from typing import Any, Optional, Union
+from urllib.parse import urlencode
+
+from google.genai import _api_module
+from google.genai import _common
+from google.genai._common import get_value_by_path as getv
+from google.genai._common import set_value_by_path as setv
+from google.genai.pagers import AsyncPager, Pager
+
+from . import _operations_utils
+from . import _skills_utils
+from . import types
+
+if typing.TYPE_CHECKING:
+    from . import skill_revisions as skill_revisions_module
+
+    _ = skill_revisions_module
+
+
+logger = logging.getLogger("agentplatform_genai.skills")
+
+
+def _CreateSkillConfig_to_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    to_object: dict[str, Any] = {}
+
+    if getv(from_object, ["zipped_filesystem"]) is not None:
+        setv(
+            parent_object,
+            ["zippedFilesystem"],
+            getv(from_object, ["zipped_filesystem"]),
+        )
+
+    return to_object
+
+
+def _CreateSkillRequestParameters_to_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ["display_name"]) is not None:
+        setv(to_object, ["displayName"], getv(from_object, ["display_name"]))
+
+    if getv(from_object, ["description"]) is not None:
+        setv(to_object, ["description"], getv(from_object, ["description"]))
+
+    if getv(from_object, ["config"]) is not None:
+        _CreateSkillConfig_to_vertex(getv(from_object, ["config"]), to_object)
+
+    if getv(from_object, ["skill_id"]) is not None:
+        setv(to_object, ["_query", "skillId"], getv(from_object, ["skill_id"]))
+
+    return to_object
+
+
+def _DeleteSkillRequestParameters_to_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ["name"]) is not None:
+        setv(to_object, ["_url", "name"], getv(from_object, ["name"]))
+
+    return to_object
+
+
+def _GetSkillOperationParameters_to_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ["operation_name"]) is not None:
+        setv(
+            to_object, ["_url", "operationName"], getv(from_object, ["operation_name"])
+        )
+
+    return to_object
+
+
+def _GetSkillRequestParameters_to_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ["name"]) is not None:
+        setv(to_object, ["_url", "name"], getv(from_object, ["name"]))
+
+    if getv(from_object, ["config"]) is not None:
+        setv(to_object, ["config"], getv(from_object, ["config"]))
+
+    return to_object
+
+
+def _ListSkillsConfig_to_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    to_object: dict[str, Any] = {}
+
+    if getv(from_object, ["page_size"]) is not None:
+        setv(parent_object, ["_query", "pageSize"], getv(from_object, ["page_size"]))
+
+    if getv(from_object, ["page_token"]) is not None:
+        setv(parent_object, ["_query", "pageToken"], getv(from_object, ["page_token"]))
+
+    if getv(from_object, ["filter"]) is not None:
+        setv(parent_object, ["_query", "filter"], getv(from_object, ["filter"]))
+
+    return to_object
+
+
+def _ListSkillsRequestParameters_to_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ["config"]) is not None:
+        setv(
+            to_object,
+            ["config"],
+            _ListSkillsConfig_to_vertex(getv(from_object, ["config"]), to_object),
+        )
+
+    return to_object
+
+
+def _RetrieveSkillsConfig_to_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    to_object: dict[str, Any] = {}
+
+    if getv(from_object, ["top_k"]) is not None:
+        setv(parent_object, ["_query", "topK"], getv(from_object, ["top_k"]))
+
+    return to_object
+
+
+def _RetrieveSkillsRequestParameters_to_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ["query"]) is not None:
+        setv(to_object, ["_query", "query"], getv(from_object, ["query"]))
+
+    if getv(from_object, ["config"]) is not None:
+        setv(
+            to_object,
+            ["config"],
+            _RetrieveSkillsConfig_to_vertex(getv(from_object, ["config"]), to_object),
+        )
+
+    return to_object
+
+
+def _UpdateSkillConfig_to_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    to_object: dict[str, Any] = {}
+
+    if getv(from_object, ["display_name"]) is not None:
+        setv(parent_object, ["displayName"], getv(from_object, ["display_name"]))
+
+    if getv(from_object, ["description"]) is not None:
+        setv(parent_object, ["description"], getv(from_object, ["description"]))
+
+    if getv(from_object, ["zipped_filesystem"]) is not None:
+        setv(
+            parent_object,
+            ["zippedFilesystem"],
+            getv(from_object, ["zipped_filesystem"]),
+        )
+
+    if getv(from_object, ["update_mask"]) is not None:
+        setv(
+            parent_object, ["_query", "updateMask"], getv(from_object, ["update_mask"])
+        )
+
+    return to_object
+
+
+def _UpdateSkillRequestParameters_to_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ["name"]) is not None:
+        setv(to_object, ["_url", "name"], getv(from_object, ["name"]))
+
+    if getv(from_object, ["config"]) is not None:
+        _UpdateSkillConfig_to_vertex(getv(from_object, ["config"]), to_object)
+
+    return to_object
+
+
+class Skills(_api_module.BaseModule):
+    """Class for managing Skills in the Skill Registry."""
+
+    def get(
+        self, *, name: str, config: Optional[types.GetSkillConfigOrDict] = None
+    ) -> types.Skill:
+        """
+        Gets a Skill.
+        """
+
+        parameter_model = types._GetSkillRequestParameters(
+            name=name,
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _GetSkillRequestParameters_to_vertex(parameter_model)
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{name}".format_map(request_url_dict)
+            else:
+                path = "{name}"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = self._api_client.request("get", path, request_dict, http_options)
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.Skill._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
+    def retrieve(
+        self, *, query: str, config: Optional[types.RetrieveSkillsConfigOrDict] = None
+    ) -> types.RetrieveSkillsResponse:
+        """
+        Retrieves skills semantically matched to a query.
+        """
+
+        parameter_model = types._RetrieveSkillsRequestParameters(
+            query=query,
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _RetrieveSkillsRequestParameters_to_vertex(parameter_model)
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "skills:retrieve".format_map(request_url_dict)
+            else:
+                path = "skills:retrieve"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = self._api_client.request("get", path, request_dict, http_options)
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.RetrieveSkillsResponse._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
+    def _create(
+        self,
+        *,
+        display_name: str,
+        description: str,
+        config: Optional[types.CreateSkillConfigOrDict] = None,
+        skill_id: str,
+    ) -> types.SkillOperation:
+        """
+        Creates a new Skill.
+        """
+
+        parameter_model = types._CreateSkillRequestParameters(
+            display_name=display_name,
+            description=description,
+            config=config,
+            skill_id=skill_id,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _CreateSkillRequestParameters_to_vertex(parameter_model)
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "skills".format_map(request_url_dict)
+            else:
+                path = "skills"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = self._api_client.request("post", path, request_dict, http_options)
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.SkillOperation._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
+    def _update(
+        self, *, name: str, config: Optional[types.UpdateSkillConfigOrDict] = None
+    ) -> types.SkillOperation:
+        """
+        Updates a Skill.
+        """
+
+        parameter_model = types._UpdateSkillRequestParameters(
+            name=name,
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _UpdateSkillRequestParameters_to_vertex(parameter_model)
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{name}".format_map(request_url_dict)
+            else:
+                path = "{name}"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = self._api_client.request("patch", path, request_dict, http_options)
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.SkillOperation._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
+    def _list(
+        self, *, config: Optional[types.ListSkillsConfigOrDict] = None
+    ) -> types.ListSkillsResponse:
+        parameter_model = types._ListSkillsRequestParameters(
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _ListSkillsRequestParameters_to_vertex(parameter_model)
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "skills".format_map(request_url_dict)
+            else:
+                path = "skills"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = self._api_client.request("get", path, request_dict, http_options)
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.ListSkillsResponse._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
+    def _delete(
+        self, *, name: str, config: Optional[types.DeleteSkillConfigOrDict] = None
+    ) -> types.DeleteSkillOperation:
+        """
+        Deletes a Skill.
+        """
+
+        parameter_model = types._DeleteSkillRequestParameters(
+            name=name,
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _DeleteSkillRequestParameters_to_vertex(parameter_model)
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{name}".format_map(request_url_dict)
+            else:
+                path = "{name}"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = self._api_client.request("delete", path, request_dict, http_options)
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.DeleteSkillOperation._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
+    def _get_skill_operation(
+        self,
+        *,
+        operation_name: str,
+        config: Optional[types.GetSkillOperationConfigOrDict] = None,
+    ) -> types.SkillOperation:
+        parameter_model = types._GetSkillOperationParameters(
+            operation_name=operation_name,
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _GetSkillOperationParameters_to_vertex(parameter_model)
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{operationName}".format_map(request_url_dict)
+            else:
+                path = "{operationName}"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = self._api_client.request("get", path, request_dict, http_options)
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.SkillOperation._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
+    def create(
+        self,
+        *,
+        skill_id: str,
+        display_name: str,
+        description: str,
+        config: Optional[types.CreateSkillConfigOrDict] = None,
+    ) -> Union[types.Skill, types.SkillOperation]:
+        """Creates a new Skill.
+
+        Args:
+            skill_id (str):
+                Required. The ID to use for the Skill, which will become the final
+                component of the Skill's resource name.
+            display_name (str):
+                Required. The display name of the Skill.
+            description (str):
+                Required. The description of the Skill.
+            config (CreateSkillConfigOrDict):
+                Optional. The configuration for creating the Skill.
+
+        Returns:
+            Skill: The created Skill if wait_for_completion is True.
+            SkillOperation: The operation for creating the Skill if
+            wait_for_completion is False.
+        """
+        if config is None:
+            config = types.CreateSkillConfig()
+        elif isinstance(config, dict):
+            config = types.CreateSkillConfig.model_validate(config)
+        elif not isinstance(config, types.CreateSkillConfig):
+            raise TypeError(
+                f"config must be a dict or CreateSkillConfig, but got {type(config)}."
+            )
+
+        config = config.model_copy()
+
+        local_path = config.local_path
+        zipped_filesystem = config.zipped_filesystem
+
+        if local_path and zipped_filesystem:
+            raise ValueError(
+                "Only one of `local_path` or `zipped_filesystem` can be provided in config."
+            )
+        if not local_path and not zipped_filesystem:
+            raise ValueError(
+                "Either `local_path` or `zipped_filesystem` must be provided in config."
+            )
+
+        if local_path:
+            zipped_filesystem_payload = _skills_utils.get_zipped_filesystem_payload(
+                local_path
+            )
+        else:
+            # Narrow type for mypy
+            if zipped_filesystem is None:
+                raise ValueError(
+                    "zipped_filesystem is required if local_path is not provided."
+                )
+            if isinstance(zipped_filesystem, bytes):
+                zipped_filesystem_payload = base64.b64encode(zipped_filesystem).decode(
+                    "utf-8"
+                )
+            else:
+                zipped_filesystem_payload = zipped_filesystem
+
+        # Mutate the config object to populate the zipped_filesystem payload
+        config.zipped_filesystem = zipped_filesystem_payload
+
+        operation = self._create(
+            skill_id=skill_id,
+            display_name=display_name,
+            description=description,
+            config=config,
+        )
+
+        if config.wait_for_completion:
+            operation = _operations_utils.await_operation(
+                operation_name=operation.name,
+                get_operation_fn=self._get_skill_operation,
+            )
+            if operation.error:
+                raise RuntimeError(f"Failed to create Skill: {operation.error}")
+            # Fetch the fully populated Skill resource from the server
+            return self.get(name=operation.response.name)
+
+        return operation
+
+    def update(
+        self,
+        *,
+        name: str,
+        config: Optional[types.UpdateSkillConfigOrDict] = None,
+    ) -> Union[types.Skill, types.SkillOperation]:
+        """Updates an existing Skill.
+
+        Args:
+            name (str):
+                Required. The resource name of the Skill to update.
+                Format: projects/{project}/locations/{location}/skills/{skill}
+            config (UpdateSkillConfigOrDict):
+                Optional. The configuration for updating the Skill.
+
+        Returns:
+            Skill: The updated Skill if wait_for_completion is True.
+            SkillOperation: The operation for updating the Skill if
+            wait_for_completion is False.
+        """
+        if config is None:
+            config = types.UpdateSkillConfig()
+        elif isinstance(config, dict):
+            config = types.UpdateSkillConfig.model_validate(config)
+        elif not isinstance(config, types.UpdateSkillConfig):
+            raise TypeError(
+                f"config must be a dict or UpdateSkillConfig, but got {type(config)}."
+            )
+
+        config = config.model_copy()
+
+        display_name = config.display_name
+        description = config.description
+        local_path = config.local_path
+        zipped_filesystem = config.zipped_filesystem
+
+        if local_path and zipped_filesystem:
+            raise ValueError(
+                "Only one of `local_path` or `zipped_filesystem` can be provided in config."
+            )
+
+        # Construct update_mask and prepare payload
+        update_mask_paths = []
+        zipped_filesystem_payload = None
+
+        if display_name is not None:
+            update_mask_paths.append("displayName")
+
+        if description is not None:
+            update_mask_paths.append("description")
+
+        if local_path:
+            zipped_filesystem_payload = _skills_utils.get_zipped_filesystem_payload(
+                local_path
+            )
+            update_mask_paths.append("zippedFilesystem")
+        elif zipped_filesystem is not None:
+            if isinstance(zipped_filesystem, bytes):
+                zipped_filesystem_payload = base64.b64encode(zipped_filesystem).decode(
+                    "utf-8"
+                )
+            else:
+                zipped_filesystem_payload = zipped_filesystem
+            update_mask_paths.append("zippedFilesystem")
+
+        if not update_mask_paths:
+            raise ValueError(
+                "At least one of `display_name`, `description`, `local_path`, or "
+                "`zipped_filesystem` must be provided for update in config."
+            )
+
+        update_mask = ",".join(update_mask_paths)
+
+        # Mutate config in place to populate the generated update_mask and zipped_filesystem
+        config.update_mask = update_mask
+        config.zipped_filesystem = zipped_filesystem_payload
+
+        operation = self._update(
+            name=name,
+            config=config,
+        )
+
+        if config.wait_for_completion:
+            operation = _operations_utils.await_operation(
+                operation_name=operation.name,
+                get_operation_fn=self._get_skill_operation,
+            )
+            if operation.error:
+                raise RuntimeError(f"Failed to update Skill: {operation.error}")
+            # Fetch the fully populated Skill resource from the server
+            return self.get(name=name)
+
+        return operation
+
+    def delete(
+        self,
+        *,
+        name: str,
+        config: Optional[types.DeleteSkillConfigOrDict] = None,
+    ) -> Optional[types.DeleteSkillOperation]:
+        """Deletes a Skill.
+
+        Args:
+            name (str):
+                Required. The resource name of the Skill to delete.
+                Format: projects/{project}/locations/{location}/skills/{skill}
+            config (DeleteSkillConfigOrDict):
+                Optional. Additional configuration for the delete operation.
+
+        Returns:
+            DeleteSkillOperation: The pending LRO if wait_for_completion is False,
+                otherwise None (blocks until done).
+        """
+        if config is None:
+            config = types.DeleteSkillConfig()
+        elif isinstance(config, dict):
+            config = types.DeleteSkillConfig.model_validate(config)
+        elif not isinstance(config, types.DeleteSkillConfig):
+            raise TypeError(
+                f"config must be a dict or DeleteSkillConfig, but got {type(config)}."
+            )
+
+        operation = self._delete(name=name, config=config)
+
+        if config.wait_for_completion:
+            operation = _operations_utils.await_operation(
+                operation_name=operation.name,
+                get_operation_fn=self._get_skill_operation,
+            )
+            if operation.error:
+                raise RuntimeError(f"Failed to delete Skill: {operation.error}")
+            return None
+
+        return operation
+
+    _revisions = None
+
+    @property
+    def revisions(self) -> "skill_revisions_module.SkillRevisions":
+        """Returns the revisions sub-module."""
+        if self._revisions is None:
+            # Lazy load to avoid circular imports
+            self._revisions = importlib.import_module(".skill_revisions", __package__)
+        return self._revisions.SkillRevisions(self._api_client)  # type: ignore[no-any-return]
+
+    def list(
+        self, *, config: Optional[types.ListSkillsConfigOrDict] = None
+    ) -> Pager[types.Skill]:
+        """
+        Lists Skills in the Skill Registry.
+
+        Args:
+            config: Optional configuration override.
+
+        """
+
+        list_request = self._list
+        return Pager(
+            "skills",
+            list_request,
+            self._list(config=config),
+            config,
+        )
+
+
+class AsyncSkills(_api_module.BaseModule):
+    """Class for managing Skills in the Skill Registry."""
+
+    async def get(
+        self, *, name: str, config: Optional[types.GetSkillConfigOrDict] = None
+    ) -> types.Skill:
+        """
+        Gets a Skill.
+        """
+
+        parameter_model = types._GetSkillRequestParameters(
+            name=name,
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _GetSkillRequestParameters_to_vertex(parameter_model)
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{name}".format_map(request_url_dict)
+            else:
+                path = "{name}"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = await self._api_client.async_request(
+            "get", path, request_dict, http_options
+        )
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.Skill._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
+    async def retrieve(
+        self, *, query: str, config: Optional[types.RetrieveSkillsConfigOrDict] = None
+    ) -> types.RetrieveSkillsResponse:
+        """
+        Retrieves skills semantically matched to a query.
+        """
+
+        parameter_model = types._RetrieveSkillsRequestParameters(
+            query=query,
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _RetrieveSkillsRequestParameters_to_vertex(parameter_model)
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "skills:retrieve".format_map(request_url_dict)
+            else:
+                path = "skills:retrieve"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = await self._api_client.async_request(
+            "get", path, request_dict, http_options
+        )
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.RetrieveSkillsResponse._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
+    async def _create(
+        self,
+        *,
+        display_name: str,
+        description: str,
+        config: Optional[types.CreateSkillConfigOrDict] = None,
+        skill_id: str,
+    ) -> types.SkillOperation:
+        """
+        Creates a new Skill.
+        """
+
+        parameter_model = types._CreateSkillRequestParameters(
+            display_name=display_name,
+            description=description,
+            config=config,
+            skill_id=skill_id,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _CreateSkillRequestParameters_to_vertex(parameter_model)
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "skills".format_map(request_url_dict)
+            else:
+                path = "skills"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = await self._api_client.async_request(
+            "post", path, request_dict, http_options
+        )
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.SkillOperation._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
+    async def _update(
+        self, *, name: str, config: Optional[types.UpdateSkillConfigOrDict] = None
+    ) -> types.SkillOperation:
+        """
+        Updates a Skill.
+        """
+
+        parameter_model = types._UpdateSkillRequestParameters(
+            name=name,
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _UpdateSkillRequestParameters_to_vertex(parameter_model)
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{name}".format_map(request_url_dict)
+            else:
+                path = "{name}"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = await self._api_client.async_request(
+            "patch", path, request_dict, http_options
+        )
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.SkillOperation._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
+    async def _list(
+        self, *, config: Optional[types.ListSkillsConfigOrDict] = None
+    ) -> types.ListSkillsResponse:
+        parameter_model = types._ListSkillsRequestParameters(
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _ListSkillsRequestParameters_to_vertex(parameter_model)
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "skills".format_map(request_url_dict)
+            else:
+                path = "skills"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = await self._api_client.async_request(
+            "get", path, request_dict, http_options
+        )
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.ListSkillsResponse._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
+    async def _delete(
+        self, *, name: str, config: Optional[types.DeleteSkillConfigOrDict] = None
+    ) -> types.DeleteSkillOperation:
+        """
+        Deletes a Skill.
+        """
+
+        parameter_model = types._DeleteSkillRequestParameters(
+            name=name,
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _DeleteSkillRequestParameters_to_vertex(parameter_model)
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{name}".format_map(request_url_dict)
+            else:
+                path = "{name}"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = await self._api_client.async_request(
+            "delete", path, request_dict, http_options
+        )
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.DeleteSkillOperation._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
+    async def _get_skill_operation(
+        self,
+        *,
+        operation_name: str,
+        config: Optional[types.GetSkillOperationConfigOrDict] = None,
+    ) -> types.SkillOperation:
+        parameter_model = types._GetSkillOperationParameters(
+            operation_name=operation_name,
+            config=config,
+        )
+
+        request_url_dict: Optional[dict[str, str]]
+        if not self._api_client.vertexai:
+            raise ValueError(
+                "This method is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode."
+            )
+        else:
+            request_dict = _GetSkillOperationParameters_to_vertex(parameter_model)
+            request_url_dict = request_dict.get("_url")
+            if request_url_dict:
+                path = "{operationName}".format_map(request_url_dict)
+            else:
+                path = "{operationName}"
+
+        query_params = request_dict.get("_query")
+        if query_params:
+            path = f"{path}?{urlencode(query_params)}"
+        # TODO: remove the hack that pops config.
+        request_dict.pop("config", None)
+
+        http_options: Optional[types.HttpOptions] = None
+        if (
+            parameter_model.config is not None
+            and parameter_model.config.http_options is not None
+        ):
+            http_options = parameter_model.config.http_options
+
+        request_dict = _common.convert_to_dict(request_dict)
+        request_dict = _common.encode_unserializable_types(request_dict)
+
+        response = await self._api_client.async_request(
+            "get", path, request_dict, http_options
+        )
+
+        response_dict = {} if not response.body else json.loads(response.body)
+
+        return_value = types.SkillOperation._from_response(
+            response=response_dict,
+            kwargs=(
+                {
+                    "config": {
+                        "response_schema": getattr(
+                            parameter_model.config, "response_schema", None
+                        ),
+                        "response_json_schema": getattr(
+                            parameter_model.config, "response_json_schema", None
+                        ),
+                        "include_all_fields": getattr(
+                            parameter_model.config, "include_all_fields", None
+                        ),
+                    }
+                }
+                if getattr(parameter_model, "config", None)
+                else {}
+            ),
+        )
+
+        self._api_client._verify_response(return_value)
+        return return_value
+
+    async def create(
+        self,
+        *,
+        skill_id: str,
+        display_name: str,
+        description: str,
+        config: Optional[types.CreateSkillConfigOrDict] = None,
+    ) -> Union[types.Skill, types.SkillOperation]:
+        """Creates a new Skill asynchronously.
+
+        Args:
+            skill_id (str):
+                Required. The ID to use for the Skill, which will become the final
+                component of the Skill's resource name.
+            display_name (str):
+                Required. The display name of the Skill.
+            description (str):
+                Required. The description of the Skill.
+            config (CreateSkillConfigOrDict):
+                Optional. The configuration for creating the Skill.
+
+        Returns:
+            Skill: The created Skill if wait_for_completion is True.
+            SkillOperation: The operation for creating the Skill if
+            wait_for_completion is False.
+        """
+        if config is None:
+            config = types.CreateSkillConfig()
+        elif isinstance(config, dict):
+            config = types.CreateSkillConfig.model_validate(config)
+        elif not isinstance(config, types.CreateSkillConfig):
+            raise TypeError(
+                f"config must be a dict or CreateSkillConfig, but got {type(config)}."
+            )
+
+        config = config.model_copy()
+
+        local_path = config.local_path
+        zipped_filesystem = config.zipped_filesystem
+
+        if local_path and zipped_filesystem:
+            raise ValueError(
+                "Only one of `local_path` or `zipped_filesystem` can be provided in config."
+            )
+        if not local_path and not zipped_filesystem:
+            raise ValueError(
+                "Either `local_path` or `zipped_filesystem` must be provided in config."
+            )
+
+        if local_path:
+            loop = asyncio.get_running_loop()
+            zipped_filesystem_payload = await loop.run_in_executor(
+                None, _skills_utils.get_zipped_filesystem_payload, local_path
+            )
+        else:
+            # Narrow type for mypy
+            if zipped_filesystem is None:
+                raise ValueError(
+                    "zipped_filesystem is required if local_path is not provided."
+                )
+            if isinstance(zipped_filesystem, bytes):
+                zipped_filesystem_payload = base64.b64encode(zipped_filesystem).decode(
+                    "utf-8"
+                )
+            else:
+                zipped_filesystem_payload = zipped_filesystem
+
+        # Mutate the config object to populate the zipped_filesystem payload
+        config.zipped_filesystem = zipped_filesystem_payload
+
+        operation = await self._create(
+            skill_id=skill_id,
+            display_name=display_name,
+            description=description,
+            config=config,
+        )
+
+        if config.wait_for_completion:
+            operation = await _operations_utils.await_operation_async(
+                operation_name=operation.name,
+                get_operation_fn=self._get_skill_operation,
+            )
+            if operation.error:
+                raise RuntimeError(f"Failed to create Skill: {operation.error}")
+            # Fetch the fully populated Skill resource asynchronously
+            return await self.get(name=operation.response.name)
+
+        return operation
+
+    async def update(
+        self,
+        *,
+        name: str,
+        config: Optional[types.UpdateSkillConfigOrDict] = None,
+    ) -> Union[types.Skill, types.SkillOperation]:
+        """Updates an existing Skill asynchronously.
+
+        Args:
+            name (str):
+                Required. The resource name of the Skill to update.
+                Format: projects/{project}/locations/{location}/skills/{skill}
+            config (UpdateSkillConfigOrDict):
+                Optional. The configuration for updating the Skill.
+
+        Returns:
+            Skill: The updated Skill if wait_for_completion is True.
+            SkillOperation: The operation for updating the Skill if
+            wait_for_completion is False.
+        """
+        if config is None:
+            config = types.UpdateSkillConfig()
+        elif isinstance(config, dict):
+            config = types.UpdateSkillConfig.model_validate(config)
+        elif not isinstance(config, types.UpdateSkillConfig):
+            raise TypeError(
+                f"config must be a dict or UpdateSkillConfig, but got {type(config)}."
+            )
+
+        config = config.model_copy()
+
+        display_name = config.display_name
+        description = config.description
+        local_path = config.local_path
+        zipped_filesystem = config.zipped_filesystem
+
+        if local_path and zipped_filesystem:
+            raise ValueError(
+                "Only one of `local_path` or `zipped_filesystem` can be provided in config."
+            )
+
+        # Construct update_mask and prepare payload
+        update_mask_paths = []
+        zipped_filesystem_payload = None
+
+        if display_name is not None:
+            update_mask_paths.append("displayName")
+
+        if description is not None:
+            update_mask_paths.append("description")
+
+        if local_path:
+            loop = asyncio.get_running_loop()
+            zipped_filesystem_payload = await loop.run_in_executor(
+                None, _skills_utils.get_zipped_filesystem_payload, local_path
+            )
+            update_mask_paths.append("zippedFilesystem")
+        elif zipped_filesystem is not None:
+            if isinstance(zipped_filesystem, bytes):
+                zipped_filesystem_payload = base64.b64encode(zipped_filesystem).decode(
+                    "utf-8"
+                )
+            else:
+                zipped_filesystem_payload = zipped_filesystem
+            update_mask_paths.append("zippedFilesystem")
+
+        if not update_mask_paths:
+            raise ValueError(
+                "At least one of `display_name`, `description`, `local_path`, or "
+                "`zipped_filesystem` must be provided for update in config."
+            )
+
+        update_mask = ",".join(update_mask_paths)
+
+        # Mutate config in place to populate the generated update_mask and zipped_filesystem
+        config.update_mask = update_mask
+        config.zipped_filesystem = zipped_filesystem_payload
+
+        operation = await self._update(
+            name=name,
+            config=config,
+        )
+
+        if config.wait_for_completion:
+            operation = await _operations_utils.await_operation_async(
+                operation_name=operation.name,
+                get_operation_fn=self._get_skill_operation,
+            )
+            if operation.error:
+                raise RuntimeError(f"Failed to update Skill: {operation.error}")
+            # Fetch the fully populated Skill resource asynchronously
+            return await self.get(name=name)
+
+        return operation
+
+    async def delete(
+        self,
+        *,
+        name: str,
+        config: Optional[types.DeleteSkillConfigOrDict] = None,
+    ) -> Optional[types.DeleteSkillOperation]:
+        """Deletes a Skill asynchronously.
+
+        Args:
+            name (str):
+                Required. The resource name of the Skill to delete.
+                Format: projects/{project}/locations/{location}/skills/{skill}
+            config (DeleteSkillConfigOrDict):
+                Optional. Additional configuration for the delete operation.
+
+        Returns:
+            DeleteSkillOperation: The pending LRO if wait_for_completion is False,
+                otherwise None (blocks until done).
+        """
+        if config is None:
+            config = types.DeleteSkillConfig()
+        elif isinstance(config, dict):
+            config = types.DeleteSkillConfig.model_validate(config)
+        elif not isinstance(config, types.DeleteSkillConfig):
+            raise TypeError(
+                f"config must be a dict or DeleteSkillConfig, but got {type(config)}."
+            )
+
+        operation = await self._delete(name=name, config=config)
+
+        if config.wait_for_completion:
+            operation = await _operations_utils.await_operation_async(
+                operation_name=operation.name,
+                get_operation_fn=self._get_skill_operation,
+            )
+            if operation.error:
+                raise RuntimeError(f"Failed to delete Skill: {operation.error}")
+            return None
+
+        return operation
+
+    _revisions = None
+
+    @property
+    def revisions(self) -> "skill_revisions_module.AsyncSkillRevisions":
+        """Returns the revisions sub-module asynchronously."""
+        if self._revisions is None:
+            self._revisions = importlib.import_module(".skill_revisions", __package__)
+        return self._revisions.AsyncSkillRevisions(self._api_client)  # type: ignore[no-any-return]
+
+    async def list(
+        self, *, config: Optional[types.ListSkillsConfigOrDict] = None
+    ) -> AsyncPager[types.Skill]:
+        list_request = self._list
+        return AsyncPager(
+            "skills",
+            list_request,
+            await self._list(config=config),
+            config,
+        )