digitalkin 0.3.0rc1__py3-none-any.whl → 0.3.1__py3-none-any.whl

digitalkin/modules/_base_module.py

@@ -107,14 +107,18 @@ class BaseModule(  # noqa: PLR0904
         return self._status
 
     @classmethod
-    def get_secret_format(cls, *, llm_format: bool) -> str:
+    async def get_secret_format(cls, *, llm_format: bool) -> str:
         """Get the JSON schema of the secret format model.
 
-        Raises:
-            NotImplementedError: If the `secret_format` is not defined.
+        Args:
+            llm_format: If True, return LLM-optimized schema format with inlined
+                references and simplified structure.
 
         Returns:
-            The JSON schema of the secret format as a string.
+            The JSON schema of the secret format as a JSON string.
+
+        Raises:
+            NotImplementedError: If the `secret_format` class attribute is not defined.
         """
         if cls.secret_format is not None:
             if llm_format:
@@ -124,14 +128,18 @@ class BaseModule(  # noqa: PLR0904
         raise NotImplementedError(msg)
 
     @classmethod
-    def get_input_format(cls, *, llm_format: bool) -> str:
+    async def get_input_format(cls, *, llm_format: bool) -> str:
         """Get the JSON schema of the input format model.
 
-        Raises:
-            NotImplementedError: If the `input_format` is not defined.
+        Args:
+            llm_format: If True, return LLM-optimized schema format with inlined
+                references and simplified structure.
 
         Returns:
-            The JSON schema of the input format as a string.
+            The JSON schema of the input format as a JSON string.
+
+        Raises:
+            NotImplementedError: If the `input_format` class attribute is not defined.
         """
         if cls.input_format is not None:
             if llm_format:
@@ -141,14 +149,18 @@ class BaseModule(  # noqa: PLR0904
         raise NotImplementedError(msg)
 
     @classmethod
-    def get_output_format(cls, *, llm_format: bool) -> str:
+    async def get_output_format(cls, *, llm_format: bool) -> str:
         """Get the JSON schema of the output format model.
 
-        Raises:
-            NotImplementedError: If the `output_format` is not defined.
+        Args:
+            llm_format: If True, return LLM-optimized schema format with inlined
+                references and simplified structure.
 
         Returns:
-            The JSON schema of the output format as a string.
+            The JSON schema of the output format as a JSON string.
+
+        Raises:
+            NotImplementedError: If the `output_format` class attribute is not defined.
         """
         if cls.output_format is not None:
             if llm_format:
@@ -158,20 +170,29 @@ class BaseModule(  # noqa: PLR0904
         raise NotImplementedError(msg)
 
     @classmethod
-    def get_config_setup_format(cls, *, llm_format: bool) -> str:
+    async def get_config_setup_format(cls, *, llm_format: bool) -> str:
         """Gets the JSON schema of the config setup format model.
 
-        The config setup format is used only to initialize the module with configuration data.
-        The setup format is used to initialize an run the module with setup data.
+        The config setup format is used only to initialize the module with configuration
+        data. It includes fields marked with `json_schema_extra={"config": True}` and
+        excludes hidden runtime fields.
 
-        Raises:
-            NotImplementedError: If the `setup_format` is not defined.
+        Dynamic schema fields are always resolved when generating the schema, as this
+        method is typically called during module discovery or schema generation where
+        fresh values are needed.
+
+        Args:
+            llm_format: If True, return LLM-optimized schema format with inlined
+                references and simplified structure.
 
         Returns:
-            The JSON schema of the config setup format as a string.
+            The JSON schema of the config setup format as a JSON string.
+
+        Raises:
+            NotImplementedError: If the `setup_format` class attribute is not defined.
         """
         if cls.setup_format is not None:
-            setup_format = cls.setup_format.get_clean_model(config_fields=True, hidden_fields=False)
+            setup_format = await cls.setup_format.get_clean_model(config_fields=True, hidden_fields=False, force=True)
             if llm_format:
                 return json.dumps(llm_ready_schema(setup_format), indent=2)
             return json.dumps(setup_format.model_json_schema(), indent=2)
@@ -179,17 +200,28 @@ class BaseModule(  # noqa: PLR0904
         raise NotImplementedError(msg)
 
     @classmethod
-    def get_setup_format(cls, *, llm_format: bool) -> str:
+    async def get_setup_format(cls, *, llm_format: bool) -> str:
         """Gets the JSON schema of the setup format model.
 
-        Raises:
-            NotImplementedError: If the `setup_format` is not defined.
+        The setup format is used at runtime and includes hidden fields but excludes
+        config-only fields. This is the schema used when running the module.
+
+        Dynamic schema fields are always resolved when generating the schema, as this
+        method is typically called during module discovery or schema generation where
+        fresh values are needed.
+
+        Args:
+            llm_format: If True, return LLM-optimized schema format with inlined
+                references and simplified structure.
 
         Returns:
-            The JSON schema of the setup format as a string.
+            The JSON schema of the setup format as a JSON string.
+
+        Raises:
+            NotImplementedError: If the `setup_format` class attribute is not defined.
         """
         if cls.setup_format is not None:
-            setup_format = cls.setup_format.get_clean_model(config_fields=False, hidden_fields=True)
+            setup_format = await cls.setup_format.get_clean_model(config_fields=False, hidden_fields=True, force=True)
             if llm_format:
                 return json.dumps(llm_ready_schema(setup_format), indent=2)
             return json.dumps(setup_format.model_json_schema(), indent=2)
@@ -221,17 +253,22 @@ class BaseModule(  # noqa: PLR0904
         return cls.input_format(**input_data)
 
     @classmethod
-    def create_setup_model(cls, setup_data: dict[str, Any], *, config_fields: bool = False) -> SetupModelT:
+    async def create_setup_model(cls, setup_data: dict[str, Any], *, config_fields: bool = False) -> SetupModelT:
         """Create the setup model from the setup data.
 
+        Creates a filtered setup model instance based on the provided data.
+        Uses `get_clean_model()` internally to get the appropriate model class
+        with field filtering applied.
+
         Args:
             setup_data: The setup data to create the model from.
             config_fields: If True, include only fields with json_schema_extra["config"] == True.
 
         Returns:
-            The setup model.
+            An instance of the setup model with the provided data.
         """
-        return cls.setup_format.get_clean_model(config_fields=config_fields, hidden_fields=True)(**setup_data)
+        model_cls = await cls.setup_format.get_clean_model(config_fields=config_fields, hidden_fields=True)
+        return model_cls(**setup_data)
 
     @classmethod
     def create_secret_model(cls, secret_data: dict[str, Any]) -> SecretModelT:
@@ -436,7 +473,8 @@ class BaseModule(  # noqa: PLR0904
 
             wrapper = config_setup_data.model_dump()
             wrapper["content"] = content.model_dump()
-            await callback(self.create_setup_model(wrapper))
+            setup_model = await self.create_setup_model(wrapper)
+            await callback(setup_model)
             self._status = ModuleStatus.STOPPING
         except Exception:
             logger.error("Error during module lifecyle")

digitalkin/services/cost/grpc_cost.py

@@ -1,14 +1,12 @@
 """This module implements the gRPC Cost strategy."""
 
-from collections.abc import Generator
-from contextlib import contextmanager
-from typing import Any, Literal
+from typing import Literal
 
-from digitalkin_proto.digitalkin.cost.v1 import cost_pb2, cost_service_pb2_grpc
+from digitalkin_proto.agentic_mesh_protocol.cost.v1 import cost_pb2, cost_service_pb2_grpc
 from google.protobuf import json_format
 
-from digitalkin.grpc_servers.utils.exceptions import ServerError
 from digitalkin.grpc_servers.utils.grpc_client_wrapper import GrpcClientWrapper
+from digitalkin.grpc_servers.utils.grpc_error_handler import GrpcErrorHandlerMixin
 from digitalkin.logger import logger
 from digitalkin.models.grpc_servers.models import ClientConfig
 from digitalkin.services.cost.cost_strategy import (
@@ -20,40 +18,9 @@ from digitalkin.services.cost.cost_strategy import (
 )
 
 
-class GrpcCost(CostStrategy, GrpcClientWrapper):
+class GrpcCost(CostStrategy, GrpcClientWrapper, GrpcErrorHandlerMixin):
     """This class implements the default Cost strategy."""
 
-    @staticmethod
-    @contextmanager
-    def _handle_grpc_errors(operation: str) -> Generator[Any, Any, Any]:
-        """Context manager for consistent gRPC error handling.
-
-        Yields:
-            Allow error handling in context.
-
-        Args:
-            operation: Description of the operation being performed.
-
-        Raises:
-            ValueError: Error with the model validation.
-            ServerError: from gRPC Client.
-            CostServiceError: Unexpected error.
-        """
-        try:
-            yield
-        except CostServiceError as e:
-            msg = f"CostServiceError in {operation}: {e}"
-            logger.exception(msg)
-            raise CostServiceError(msg) from e
-        except ServerError as e:
-            msg = f"gRPC {operation} failed: {e}"
-            logger.exception(msg)
-            raise ServerError(msg) from e
-        except Exception as e:
-            msg = f"Unexpected error in {operation}"
-            logger.exception(msg)
-            raise CostServiceError(msg) from e
-
     def __init__(
         self,
         mission_id: str,
@@ -66,7 +33,7 @@ class GrpcCost(CostStrategy, GrpcClientWrapper):
         super().__init__(mission_id=mission_id, setup_id=setup_id, setup_version_id=setup_version_id, config=config)
         channel = self._init_channel(client_config)
         self.stub = cost_service_pb2_grpc.CostServiceStub(channel)
-        logger.debug("Channel client 'Cost' initialized succesfully")
+        logger.debug("Channel client 'Cost' initialized successfully")
 
     def add(
         self,
@@ -84,7 +51,7 @@ class GrpcCost(CostStrategy, GrpcClientWrapper):
         Raises:
             CostServiceError: If the cost config is invalid
         """
-        with self._handle_grpc_errors("AddCost"):
+        with self.handle_grpc_errors("AddCost", CostServiceError):
             cost_config = self.config.get(cost_config_name)
             if cost_config is None:
                 msg = f"Cost config {cost_config_name} not found in the configuration."
@@ -122,7 +89,7 @@ class GrpcCost(CostStrategy, GrpcClientWrapper):
         Returns:
             CostData: The cost data
         """
-        with self._handle_grpc_errors("GetCost"):
+        with self.handle_grpc_errors("GetCost", CostServiceError):
             request = cost_pb2.GetCostRequest(name=name, mission_id=self.mission_id)
             response: cost_pb2.GetCostResponse = self.exec_grpc_query("GetCost", request)
             cost_data_list = [
@@ -150,7 +117,7 @@ class GrpcCost(CostStrategy, GrpcClientWrapper):
         Returns:
             list[CostData]: The cost data
         """
-        with self._handle_grpc_errors("GetCosts"):
+        with self.handle_grpc_errors("GetCosts", CostServiceError):
             request = cost_pb2.GetCostsRequest(
                 mission_id=self.mission_id,
                 filter=cost_pb2.CostFilter(

digitalkin/services/filesystem/grpc_filesystem.py

@@ -1,15 +1,13 @@
 """gRPC filesystem implementation."""
 
-from collections.abc import Generator
-from contextlib import contextmanager
 from typing import Any, Literal
 
-from digitalkin_proto.digitalkin.filesystem.v1 import filesystem_pb2, filesystem_service_pb2_grpc
+from digitalkin_proto.agentic_mesh_protocol.filesystem.v1 import filesystem_pb2, filesystem_service_pb2_grpc
 from google.protobuf import struct_pb2
 from google.protobuf.json_format import MessageToDict
 
-from digitalkin.grpc_servers.utils.exceptions import ServerError
 from digitalkin.grpc_servers.utils.grpc_client_wrapper import GrpcClientWrapper
+from digitalkin.grpc_servers.utils.grpc_error_handler import GrpcErrorHandlerMixin
 from digitalkin.logger import logger
 from digitalkin.models.grpc_servers.models import ClientConfig
 from digitalkin.services.filesystem.filesystem_strategy import (
@@ -21,36 +19,9 @@ from digitalkin.services.filesystem.filesystem_strategy import (
 )
 
 
-class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper):
+class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper, GrpcErrorHandlerMixin):
     """Default state filesystem strategy."""
 
-    @staticmethod
-    @contextmanager
-    def _handle_grpc_errors(operation: str) -> Generator[Any, Any, Any]:
-        """Context manager for consistent gRPC error handling.
-
-        Yields:
-            Allow error handling in context.
-
-        Args:
-            operation: Description of the operation being performed.
-
-        Raises:
-            ValueError: Error with the model validation.
-            ServerError: from gRPC Client.
-            FilesystemServiceError: Filesystem service internal.
-        """
-        try:
-            yield
-        except ServerError as e:
-            msg = f"gRPC {operation} failed: {e}"
-            logger.exception(msg)
-            raise ServerError(msg) from e
-        except Exception as e:
-            msg = f"Unexpected error in {operation}"
-            logger.exception(msg)
-            raise FilesystemServiceError(msg) from e
-
     @staticmethod
     def _file_type_to_enum(file_type: str) -> filesystem_pb2.FileType:
         """Convert a file type string to a FileType enum.
@@ -148,7 +119,7 @@ class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper):
         self.service_name = "FilesystemService"
         channel = self._init_channel(client_config)
         self.stub = filesystem_service_pb2_grpc.FilesystemServiceStub(channel)
-        logger.debug("Channel client 'Filesystem' initialized succesfully")
+        logger.debug("Channel client 'Filesystem' initialized successfully")
 
     def upload_files(
         self,
@@ -163,7 +134,7 @@ class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper):
             tuple[list[FilesystemRecord], int, int]: List of uploaded files, total uploaded count, total failed count
         """
         logger.debug("Uploading %d files", len(files))
-        with GrpcFilesystem._handle_grpc_errors("UploadFiles"):
+        with self.handle_grpc_errors("UploadFiles", FilesystemServiceError):
             upload_files: list[filesystem_pb2.UploadFileData] = []
             for file in files:
                 metadata_struct: struct_pb2.Struct | None = None
@@ -213,7 +184,7 @@ class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper):
                 context_id = self.setup_id
             case "mission":
                 context_id = self.mission_id
-        with GrpcFilesystem._handle_grpc_errors("GetFile"):
+        with self.handle_grpc_errors("GetFile", FilesystemServiceError):
             request = filesystem_pb2.GetFileRequest(
                 context=context_id,
                 file_id=file_id,
@@ -261,7 +232,7 @@ class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper):
         Raises:
             FilesystemServiceError: If there is an error during update
         """
-        with GrpcFilesystem._handle_grpc_errors("UpdateFile"):
+        with self.handle_grpc_errors("UpdateFile", FilesystemServiceError):
             request = filesystem_pb2.UpdateFileRequest(
                 context=self.mission_id,
                 file_id=file_id,
@@ -295,7 +266,7 @@ class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper):
         Returns:
             tuple[dict[str, bool], int, int]: Results per file, total deleted count, total failed count
         """
-        with GrpcFilesystem._handle_grpc_errors("DeleteFiles"):
+        with self.handle_grpc_errors("DeleteFiles", FilesystemServiceError):
             request = filesystem_pb2.DeleteFilesRequest(
                 context=self.mission_id,
                 filters=self._filter_to_proto(filters),
@@ -332,7 +303,7 @@ class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper):
                 context_id = self.setup_id
             case "mission":
                 context_id = self.mission_id
-        with GrpcFilesystem._handle_grpc_errors("GetFiles"):
+        with self.handle_grpc_errors("GetFiles", FilesystemServiceError):
             request = filesystem_pb2.GetFilesRequest(
                 context=context_id,
                 filters=self._filter_to_proto(filters),

digitalkin/services/services_config.py

@@ -12,6 +12,7 @@ from digitalkin.services.registry import DefaultRegistry, RegistryStrategy
 from digitalkin.services.services_models import ServicesMode, ServicesStrategy
 from digitalkin.services.snapshot import DefaultSnapshot, SnapshotStrategy
 from digitalkin.services.storage import DefaultStorage, GrpcStorage, StorageStrategy
+from digitalkin.services.user_profile import DefaultUserProfile, GrpcUserProfile, UserProfileStrategy
 
 
 class ServicesConfig(BaseModel):
@@ -53,6 +54,10 @@ class ServicesConfig(BaseModel):
         default_factory=lambda: ServicesStrategy(local=DefaultIdentity, remote=DefaultIdentity)
     )
     _config_identity: dict[str, Any | None] = PrivateAttr(default_factory=dict)
+    _user_profile: ServicesStrategy[UserProfileStrategy] = PrivateAttr(
+        default_factory=lambda: ServicesStrategy(local=DefaultUserProfile, remote=GrpcUserProfile)
+    )
+    _config_user_profile: dict[str, Any | None] = PrivateAttr(default_factory=dict)
 
     # List of valid strategy names for validation
     _valid_strategy_names: ClassVar[set[str]] = {
@@ -63,6 +68,7 @@ class ServicesConfig(BaseModel):
         "filesystem",
         "agent",
         "identity",
+        "user_profile",
     }
 
     def __init__(
@@ -169,6 +175,11 @@ class ServicesConfig(BaseModel):
         """Get the identity service strategy class based on the current mode."""
         return self._identity[self.mode.value]
 
+    @property
+    def user_profile(self) -> type[UserProfileStrategy]:
+        """Get the user_profile service strategy class based on the current mode."""
+        return self._user_profile[self.mode.value]
+
     def update_mode(self, mode: ServicesMode) -> None:
         """Update the strategy mode.
 

digitalkin/services/services_models.py

@@ -13,6 +13,7 @@ from digitalkin.services.identity import IdentityStrategy
 from digitalkin.services.registry import RegistryStrategy
 from digitalkin.services.snapshot import SnapshotStrategy
 from digitalkin.services.storage import StorageStrategy
+from digitalkin.services.user_profile import UserProfileStrategy
 
 # Define type variables
 T = TypeVar(
@@ -23,7 +24,8 @@ T = TypeVar(
     | IdentityStrategy
     | RegistryStrategy
     | SnapshotStrategy
-    | StorageStrategy,
+    | StorageStrategy
+    | UserProfileStrategy,
 )
 
 

digitalkin/services/setup/default_setup.py

@@ -7,8 +7,7 @@ from typing import Any
 from pydantic import ValidationError
 
 from digitalkin.logger import logger
-from digitalkin.services.setup.grpc_setup import SetupData, SetupVersionData
-from digitalkin.services.setup.setup_strategy import SetupServiceError, SetupStrategy
+from digitalkin.services.setup.setup_strategy import SetupData, SetupServiceError, SetupStrategy, SetupVersionData
 
 
 class DefaultSetup(SetupStrategy):
@@ -47,7 +46,7 @@ class DefaultSetup(SetupStrategy):
         )
         valid_data.id = setup_id
         self.setups[setup_id] = valid_data
-        logger.debug("CREATE SETUP DATA %s:%s succesfull", setup_id, valid_data)
+        logger.debug("CREATE SETUP DATA %s:%s successful", setup_id, valid_data)
         return setup_id
 
     def get_setup(self, setup_dict: dict[str, Any]) -> SetupData:
@@ -131,7 +130,7 @@ class DefaultSetup(SetupStrategy):
         if setup_version_dict["setup_id"] not in self.setup_versions:
             self.setup_versions[setup_version_dict["setup_id"]] = {}
         self.setup_versions[setup_version_dict["setup_id"]][valid_data.version] = valid_data
-        logger.debug("CREATE SETUP VERSION DATA %s:%s succesfull", setup_version_dict["setup_id"], valid_data)
+        logger.debug("CREATE SETUP VERSION DATA %s:%s successful", setup_version_dict["setup_id"], valid_data)
         return valid_data.version
 
     def get_setup_version(self, setup_version_dict: dict[str, Any]) -> SetupVersionData:
@@ -173,7 +172,7 @@ class DefaultSetup(SetupStrategy):
 
         return [
             value
-            for value in setup_version_dict["setup_id"].values()
+            for value in self.setup_versions[setup_version_dict["setup_id"]].values()
             if setup_version_dict["query_versions"] in value.version or setup_version_dict["name"] in value.name
         ]
 
@@ -190,7 +189,7 @@ class DefaultSetup(SetupStrategy):
             logger.debug("UPDATE setup_id = %s: setup_id DOESN'T EXIST", setup_version_dict["setup_id"])
             return False
 
-        if setup_version_dict["version"] not in self.setup_versions["setup_id"]:
+        if setup_version_dict["version"] not in self.setup_versions[setup_version_dict["setup_id"]]:
             logger.debug("UPDATE setup_id = %s: setup_id DOESN'T EXIST", setup_version_dict["setup_id"])
             return False
 

digitalkin/services/setup/grpc_setup.py

@@ -5,7 +5,7 @@ from contextlib import contextmanager
 from typing import Any
 
 import grpc
-from digitalkin_proto.digitalkin.setup.v2 import (
+from digitalkin_proto.agentic_mesh_protocol.setup.v1 import (
     setup_pb2,
     setup_service_pb2_grpc,
 )
@@ -30,10 +30,10 @@ class GrpcSetup(SetupStrategy, GrpcClientWrapper):
         """
         channel = self._init_channel(config)
         self.stub = setup_service_pb2_grpc.SetupServiceStub(channel)
-        logger.debug("Channel client 'setup' initialized succesfully")
+        logger.debug("Channel client 'setup' initialized successfully")
 
     @contextmanager
-    def _handle_grpc_errors(self, operation: str) -> Generator[Any, Any, Any]:  # noqa: PLR6301
+    def handle_grpc_errors(self, operation: str) -> Generator[Any, Any, Any]:  # noqa: PLR6301
         """Context manager for consistent gRPC error handling.
 
         Yields:
@@ -76,7 +76,7 @@ class GrpcSetup(SetupStrategy, GrpcClientWrapper):
             ServerError: If gRPC operation fails.
             SetupServiceError: For any unexpected internal error.
         """
-        with self._handle_grpc_errors("Setup Creation"):
+        with self.handle_grpc_errors("Setup Creation"):
             valid_data = SetupData.model_validate(setup_dict)
 
             request = setup_pb2.CreateSetupRequest(
@@ -104,7 +104,7 @@ class GrpcSetup(SetupStrategy, GrpcClientWrapper):
             ServerError: If gRPC operation fails.
             SetupServiceError: For any unexpected internal error.
         """
-        with self._handle_grpc_errors("Get Setup"):
+        with self.handle_grpc_errors("Get Setup"):
             if "setup_id" not in setup_dict:
                 msg = "Setup name is required"
                 raise ValidationError(msg)
@@ -132,7 +132,7 @@ class GrpcSetup(SetupStrategy, GrpcClientWrapper):
         """
         current_setup_version = None
 
-        with self._handle_grpc_errors("Setup Update"):
+        with self.handle_grpc_errors("Setup Update"):
             valid_data = SetupData.model_validate(setup_dict)
 
             if valid_data.current_setup_version is not None:
@@ -162,7 +162,7 @@ class GrpcSetup(SetupStrategy, GrpcClientWrapper):
             ServerError: If gRPC operation fails.
             SetupServiceError: For any unexpected internal error.
         """
-        with self._handle_grpc_errors("Setup Deletion"):
+        with self.handle_grpc_errors("Setup Deletion"):
             setup_id = setup_dict.get("setup_id")
             if not setup_id:
                 msg = "Setup name is required for deletion"
@@ -186,7 +186,7 @@ class GrpcSetup(SetupStrategy, GrpcClientWrapper):
             ServerError: If gRPC operation fails.
             SetupServiceError: For any unexpected internal error.
         """
-        with self._handle_grpc_errors("Setup Version Creation"):
+        with self.handle_grpc_errors("Setup Version Creation"):
             valid_data = SetupVersionData.model_validate(setup_version_dict)
             content_struct = Struct()
             content_struct.update(valid_data.content)
@@ -216,14 +216,16 @@ class GrpcSetup(SetupStrategy, GrpcClientWrapper):
             ServerError: If gRPC operation fails.
             SetupServiceError: For any unexpected internal error.
         """
-        with self._handle_grpc_errors("Get Setup Version"):
+        with self.handle_grpc_errors("Get Setup Version"):
             setup_version_id = setup_version_dict.get("setup_version_id")
             if not setup_version_id:
                 msg = "Setup version id is required"
                 raise ValidationError(msg)
             request = setup_pb2.GetSetupVersionRequest(setup_version_id=setup_version_id)
             response = self.exec_grpc_query("GetSetupVersion", request)
-            return SetupVersionData(**json_format.MessageToDict(response.setup_version))
+            return SetupVersionData(
+                **json_format.MessageToDict(response.setup_version, preserving_proto_field_name=True)
+            )
 
     def search_setup_versions(self, setup_version_dict: dict[str, Any]) -> list[SetupVersionData]:
         """Search for setup versions based on filters.
@@ -239,7 +241,7 @@ class GrpcSetup(SetupStrategy, GrpcClientWrapper):
             SetupServiceError: For any unexpected internal error.
             ValidationError: If both name and version are not provided.
         """
-        with self._handle_grpc_errors("Search Setup Versions"):
+        with self.handle_grpc_errors("Search Setup Versions"):
             if "name" not in setup_version_dict and "version" not in setup_version_dict:
                 msg = "Either name or version must be provided"
                 raise ValidationError(msg)
@@ -248,7 +250,10 @@ class GrpcSetup(SetupStrategy, GrpcClientWrapper):
                 version=setup_version_dict.get("version", ""),
             )
             response = self.exec_grpc_query("SearchSetupVersions", request)
-            return [SetupVersionData(**json_format.MessageToDict(sv)) for sv in response.setup_versions]
+            return [
+                SetupVersionData(**json_format.MessageToDict(sv, preserving_proto_field_name=True))
+                for sv in response.setup_versions
+            ]
 
     def update_setup_version(self, setup_version_dict: dict[str, Any]) -> bool:
         """Update an existing setup version.
@@ -264,7 +269,7 @@ class GrpcSetup(SetupStrategy, GrpcClientWrapper):
             ServerError: If gRPC operation fails.
             SetupServiceError: For any unexpected internal error.
         """
-        with self._handle_grpc_errors("Setup Version Update"):
+        with self.handle_grpc_errors("Setup Version Update"):
             valid_data = SetupVersionData.model_validate(setup_version_dict)
             content_struct = Struct()
             content_struct.update(valid_data.content)
@@ -295,7 +300,7 @@ class GrpcSetup(SetupStrategy, GrpcClientWrapper):
             ServerError: If gRPC operation fails.
             SetupServiceError: For any unexpected internal error.
         """
-        with self._handle_grpc_errors("Setup Version Deletion"):
+        with self.handle_grpc_errors("Setup Version Deletion"):
             setup_version_id = setup_version_dict.get("setup_version_id")
             if not setup_version_id:
                 msg = "Setup version id is required for deletion"
@@ -304,3 +309,35 @@ class GrpcSetup(SetupStrategy, GrpcClientWrapper):
             response = self.exec_grpc_query("DeleteSetupVersion", request)
             logger.debug("Setup Version '%s' query sent successfully", setup_version_id)
             return getattr(response, "success", False)
+
+    def list_setups(self, list_dict: dict[str, Any]) -> dict[str, Any]:
+        """List setups with optional filtering and pagination.
+
+        Args:
+            list_dict: Dictionary with optional filters:
+                - organisation_id: Filter by organisation
+                - owner_id: Filter by owner
+                - limit: Maximum number of results
+                - offset: Number of results to skip
+
+        Returns:
+            dict[str, Any]: Dictionary with 'setups' list and 'total_count'.
+
+        Raises:
+            ServerError: If gRPC operation fails.
+            SetupServiceError: For any unexpected internal error.
+        """
+        with self.handle_grpc_errors("List Setups"):
+            request = setup_pb2.ListSetupsRequest(
+                organisation_id=list_dict.get("organisation_id", ""),
+                owner_id=list_dict.get("owner_id", ""),
+                limit=list_dict.get("limit", 0),
+                offset=list_dict.get("offset", 0),
+            )
+            response = self.exec_grpc_query("ListSetups", request)
+            return {
+                "setups": [
+                    json_format.MessageToDict(setup, preserving_proto_field_name=True) for setup in response.setups
+                ],
+                "total_count": response.total_count,
+            }

digitalkin/services/storage/grpc_storage.py

@@ -1,6 +1,6 @@
 """This module implements the default storage strategy."""
 
-from digitalkin_proto.digitalkin.storage.v2 import data_pb2, storage_service_pb2_grpc
+from digitalkin_proto.agentic_mesh_protocol.storage.v1 import data_pb2, storage_service_pb2_grpc
 from google.protobuf import json_format
 from google.protobuf.struct_pb2 import Struct
 from pydantic import BaseModel
@@ -211,4 +211,4 @@ class GrpcStorage(StorageStrategy, GrpcClientWrapper):
 
         channel = self._init_channel(client_config)
         self.stub = storage_service_pb2_grpc.StorageServiceStub(channel)
-        logger.debug("Channel client 'storage' initialized succesfully")
+        logger.debug("Channel client 'storage' initialized successfully")

digitalkin/services/user_profile/__init__.py

@@ -0,0 +1,12 @@
+"""UserProfile service package."""
+
+from digitalkin.services.user_profile.default_user_profile import DefaultUserProfile
+from digitalkin.services.user_profile.grpc_user_profile import GrpcUserProfile
+from digitalkin.services.user_profile.user_profile_strategy import UserProfileServiceError, UserProfileStrategy
+
+__all__ = [
+    "DefaultUserProfile",
+    "GrpcUserProfile",
+    "UserProfileServiceError",
+    "UserProfileStrategy",
+]