@camera.ui/server 0.0.49 → 0.0.50-internal.0

package/dist/server/src/_camera_ui_tools/camera_ui_rpc_client/base/errors.py

@@ -0,0 +1,745 @@
+import json
+import traceback
+from collections.abc import Awaitable
+from enum import Enum
+from typing import Any, Callable, Final, TypedDict, cast
+
+from typing_extensions import NotRequired
+
+
+# Error Codes
+class ERROR_CODES:
+    class CONNECTION:
+        FAILED: Final[str] = "CONNECTION_FAILED"
+        TIMEOUT: Final[str] = "CONNECTION_TIMEOUT"
+        NOT_CONNECTED: Final[str] = "CONNECTION_NOT_CONNECTED"
+        INVALID_STATE: Final[str] = "CONNECTION_INVALID_STATE"
+        INTERNAL_ERROR: Final[str] = "CONNECTION_INTERNAL_ERROR"
+
+    class CONFIG:
+        MISSING: Final[str] = "CONFIG_MISSING"
+        INVALID: Final[str] = "CONFIG_INVALID"
+        INTERNAL_ERROR: Final[str] = "CONFIG_INTERNAL_ERROR"
+
+    class AUTH:
+        INVALID_CREDENTIALS: Final[str] = "AUTH_INVALID_CREDENTIALS"
+        UNAUTHORIZED: Final[str] = "AUTH_UNAUTHORIZED"
+        FORBIDDEN: Final[str] = "AUTH_FORBIDDEN"
+        INTERNAL_ERROR: Final[str] = "AUTH_INTERNAL_ERROR"
+
+    class CLIENT:
+        REGISTRATION_FAILED: Final[str] = "CLIENT_REGISTRATION_FAILED"
+        UNREGISTRATION_FAILED: Final[str] = "CLIENT_UNREGISTRATION_FAILED"
+        NOT_FOUND: Final[str] = "CLIENT_NOT_FOUND"
+        INVALID_STATE: Final[str] = "CLIENT_INVALID_STATE"
+        INTERNAL_ERROR: Final[str] = "CLIENT_INTERNAL_ERROR"
+
+    class MESSAGE:
+        INVALID_FORMAT: Final[str] = "MESSAGE_INVALID_FORMAT"
+        DELIVERY_FAILED: Final[str] = "MESSAGE_DELIVERY_FAILED"
+        TIMEOUT: Final[str] = "MESSAGE_TIMEOUT"
+        EXECUTION_FAILED: Final[str] = "MESSAGE_EXECUTION_FAILED"
+        INTERNAL_ERROR: Final[str] = "MESSAGE_INTERNAL_ERROR"
+
+    class RPC:
+        METHOD_NOT_FOUND: Final[str] = "RPC_METHOD_NOT_FOUND"
+        INVALID_REQUEST: Final[str] = "RPC_INVALID_REQUEST"
+        INTERNAL_ERROR: Final[str] = "RPC_INTERNAL_ERROR"
+        CONNECTION_FAILED: Final[str] = "RPC_CONNECTION_FAILED"
+
+    class REGISTRY:
+        INTERNAL_ERROR: Final[str] = "REGISTRY_INTERNAL_ERROR"
+
+    class CLUSTER:
+        JOIN_FAILED: Final[str] = "CLUSTER_JOIN_FAILED"
+        SYNC_FAILED: Final[str] = "CLUSTER_SYNC_FAILED"
+        COMMUNICATION_FAILED: Final[str] = "CLUSTER_COMMUNICATION_FAILED"
+        INVALID_STATE: Final[str] = "CLUSTER_INVALID_STATE"
+        NODE_NOT_FOUND: Final[str] = "CLUSTER_NODE_NOT_FOUND"
+        INSTANCE_NOT_FOUND: Final[str] = "CLUSTER_INSTANCE_NOT_FOUND"
+        INTERNAL_ERROR: Final[str] = "CLUSTER_INTERNAL_ERROR"
+
+
+# Types
+class ErrorType(str, Enum):
+    CONFIG = "config"
+    CONNECTION = "connection"
+    AUTH = "auth"
+    CLIENT = "client"
+    MESSAGE = "message"
+    RPC = "rpc"
+    REGISTRY = "registry"
+    CLUSTER = "cluster"
+
+
+class ErrorDetails(TypedDict):
+    description: str
+    subject: NotRequired[str | None]
+    code: NotRequired[str | None]
+    metadata: NotRequired[dict[str, Any] | None]
+
+
+class ErrorDetailsPartial(ErrorDetails, total=False):
+    pass
+
+
+class SerializedError(TypedDict):
+    name: str
+    message: str
+    code: str
+    details: ErrorDetails
+    stack: NotRequired[str | None]
+    cause: NotRequired["SerializedError | None"]
+
+
+class NatsError(Exception):
+    code: str
+    details: ErrorDetails
+    cause: Exception | None
+    stack: str
+
+    def __init__(self, message: str, code: str, details: ErrorDetails, cause: Exception | None = None):
+        super().__init__(message)
+        self.code = code
+        self.details = details
+        self.cause = cause
+        self.stack = "".join(traceback.format_stack())
+        self.__class__.__module__ = "builtins"
+
+    def to_json(self) -> SerializedError:
+        error: SerializedError = {
+            "name": self.__class__.__name__,
+            "message": str(self),
+            "code": self.code,
+            "details": self.details,  # Remove json.dumps here
+            "stack": self.stack,
+            "cause": None,
+        }
+
+        if self.cause:
+            if isinstance(self.cause, NatsError):
+                error["cause"] = self.cause.to_json()
+            else:
+                error["cause"] = {
+                    "name": self.cause.__class__.__name__,
+                    "message": str(self.cause),
+                    "code": "INTERNAL_ERROR",
+                    "details": {"description": str(self.cause)},  # Remove json.dumps here
+                    "stack": None,
+                    "cause": None,
+                }
+
+        return error
+
+    @classmethod
+    def from_json(cls, json: SerializedError) -> "NatsError":
+        return cls(
+            json["message"],
+            json["code"],
+            json["details"],
+            cls.from_json(json["cause"]) if json and "cause" in json and json["cause"] else None,
+        )
+
+    def get_error_summary(self) -> str:
+        return cast(str, self.args[0])
+
+    def __str__(self) -> str:
+        # Format the main error message without module path
+        error_dict: SerializedError = {
+            "name": self.__class__.__name__.split(".")[-1],
+            "message": self.args[0],
+            "code": self.code,
+            "details": self.details,  # Don't encode details as JSON string
+        }
+
+        # Add cause if present
+        if self.cause:
+            if isinstance(self.cause, NatsError):
+                cause_dict: SerializedError = {
+                    "name": self.cause.__class__.__name__,
+                    "message": str(self.cause.args[0]),
+                    "code": self.cause.code,
+                    "details": self.cause.details,  # Don't encode details as JSON string
+                }
+            else:
+                cause_dict = {
+                    "name": self.cause.__class__.__name__,
+                    "message": str(self.cause),
+                    "code": "INTERNAL_ERROR",
+                    "details": {"description": str(self.cause)},
+                }
+            error_dict["cause"] = cause_dict
+
+        # Convert to JSON string with proper indentation
+        return f"{self.__class__.__name__.split('.')[-1]}: {self.args[0]}\n{json.dumps(error_dict, indent=2)}"
+
+
+# Specialized error classes
+class ConnectionError(NatsError):
+    def __init__(self, message: str, details: ErrorDetails, cause: Exception | None = None):
+        super().__init__(message, ERROR_CODES.CONNECTION.INTERNAL_ERROR, details, cause)
+
+
+class ConfigError(NatsError):
+    def __init__(self, message: str, details: ErrorDetails, cause: Exception | None = None):
+        super().__init__(message, ERROR_CODES.CONFIG.INTERNAL_ERROR, details, cause)
+
+
+class AuthError(NatsError):
+    def __init__(self, message: str, details: ErrorDetails, cause: Exception | None = None):
+        super().__init__(message, ERROR_CODES.AUTH.INTERNAL_ERROR, details, cause)
+
+
+class ClientError(NatsError):
+    def __init__(self, message: str, details: ErrorDetails, cause: Exception | None = None):
+        super().__init__(message, ERROR_CODES.CLIENT.INTERNAL_ERROR, details, cause)
+
+
+class MessageError(NatsError):
+    def __init__(self, message: str, details: ErrorDetails, cause: Exception | None = None):
+        super().__init__(message, ERROR_CODES.MESSAGE.INTERNAL_ERROR, details, cause)
+
+
+class RPCError(NatsError):
+    def __init__(self, message: str, details: ErrorDetails, cause: Exception | None = None):
+        super().__init__(message, ERROR_CODES.RPC.INTERNAL_ERROR, details, cause)
+
+
+class RegistryError(NatsError):
+    def __init__(self, message: str, details: ErrorDetails, cause: Exception | None = None):
+        super().__init__(message, ERROR_CODES.REGISTRY.INTERNAL_ERROR, details, cause)
+
+
+class ClusterError(NatsError):
+    def __init__(self, message: str, details: ErrorDetails, cause: Exception | None = None):
+        super().__init__(message, ERROR_CODES.CLUSTER.INTERNAL_ERROR, details, cause)
+
+
+def is_nats_error(error: Any) -> bool:
+    return isinstance(error, NatsError)
+
+
+class ErrorFactory:
+    @staticmethod
+    def create(type_: ErrorType, error: Any, message: str, details: ErrorDetails) -> NatsError:
+        if isinstance(error, NatsError):
+            return error
+
+        cause = error if isinstance(error, Exception) else Exception(str(error))
+        sanitized_details = sanitize_details(details)
+
+        ERROR_CLASSES: dict[ErrorType, Any] = {
+            ErrorType.CONNECTION: ConnectionError,
+            ErrorType.CONFIG: ConfigError,
+            ErrorType.AUTH: AuthError,
+            ErrorType.CLIENT: ClientError,
+            ErrorType.MESSAGE: MessageError,
+            ErrorType.RPC: RPCError,
+            ErrorType.REGISTRY: RegistryError,
+            ErrorType.CLUSTER: ClusterError,
+        }
+
+        return cast(NatsError, ERROR_CLASSES[type_](message, sanitized_details, cause))
+
+    class connection:
+        @staticmethod
+        def connection_failed(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.CONNECTION,
+                error,
+                "Connection failed",
+                {
+                    "description": "Failed to establish connection",
+                    "code": ERROR_CODES.CONNECTION.FAILED,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def subscribe_failed(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.CONNECTION,
+                error,
+                "Subscription failed",
+                {
+                    "description": "Failed to subscribe to subject",
+                    "code": ERROR_CODES.CONNECTION.INTERNAL_ERROR,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def request_failed(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.CONNECTION,
+                error,
+                "Request failed",
+                {
+                    "description": "Failed to send request",
+                    "code": ERROR_CODES.CONNECTION.INTERNAL_ERROR,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def timeout(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.CONNECTION,
+                error,
+                "Connection timeout",
+                {
+                    "description": "Connection attempt timed out",
+                    "code": ERROR_CODES.CONNECTION.TIMEOUT,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def not_connected(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.CONNECTION,
+                error,
+                "Not connected",
+                {
+                    "description": "Connection is not established",
+                    "code": ERROR_CODES.CONNECTION.NOT_CONNECTED,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def invalid_state(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.CONNECTION,
+                error,
+                "Invalid state",
+                {
+                    "description": "Connection is in an invalid state",
+                    "code": ERROR_CODES.CONNECTION.INVALID_STATE,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def internal_error(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.CONNECTION,
+                error,
+                "Internal error",
+                {
+                    "description": "Internal error occurred",
+                    "code": ERROR_CODES.CONNECTION.INTERNAL_ERROR,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+    class config:
+        @staticmethod
+        def missing(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.CONFIG,
+                error,
+                "Missing configuration",
+                {
+                    "description": "Required configuration is missing",
+                    "code": ERROR_CODES.CONFIG.MISSING,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def invalid(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.CONFIG,
+                error,
+                "Invalid configuration",
+                {
+                    "description": "Invalid configuration provided",
+                    "code": ERROR_CODES.CONFIG.INVALID,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def internal_error(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.CONFIG,
+                error,
+                "Internal error",
+                {
+                    "description": "Internal error occurred",
+                    "code": ERROR_CODES.CONFIG.INTERNAL_ERROR,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+    class auth:
+        @staticmethod
+        def unauthorized(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.AUTH,
+                error,
+                "Unauthorized",
+                {
+                    "description": "Authentication failed",
+                    "code": ERROR_CODES.AUTH.UNAUTHORIZED,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def forbidden(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.AUTH,
+                error,
+                "Forbidden",
+                {
+                    "description": "Insufficient permissions",
+                    "code": ERROR_CODES.AUTH.FORBIDDEN,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def internal_error(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.AUTH,
+                error,
+                "Internal error",
+                {
+                    "description": "Internal error occurred",
+                    "code": ERROR_CODES.AUTH.INTERNAL_ERROR,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+    class client:
+        @staticmethod
+        def registration_failed(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.CLIENT,
+                error,
+                "Registration failed",
+                {
+                    "description": "Failed to register client",
+                    "code": ERROR_CODES.CLIENT.REGISTRATION_FAILED,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def not_found(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.CLIENT,
+                error,
+                "Not found",
+                {
+                    "description": "Requested client could not be found",
+                    "code": ERROR_CODES.CLIENT.NOT_FOUND,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def invalid_state(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.CLIENT,
+                error,
+                "Invalid state",
+                {
+                    "description": "Client is in an invalid state",
+                    "code": ERROR_CODES.CLIENT.INVALID_STATE,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def internal_error(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.CLIENT,
+                error,
+                "Internal error",
+                {
+                    "description": "Internal error occurred",
+                    "code": ERROR_CODES.CLIENT.INTERNAL_ERROR,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+    class message:
+        @staticmethod
+        def invalid_format(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.MESSAGE,
+                error,
+                "Invalid format",
+                {
+                    "description": "Failed to parse message",
+                    "code": ERROR_CODES.MESSAGE.INVALID_FORMAT,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def delivery_failed(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.MESSAGE,
+                error,
+                "Delivery failed",
+                {
+                    "description": "Failed to deliver message",
+                    "code": ERROR_CODES.MESSAGE.DELIVERY_FAILED,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def timeout(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.MESSAGE,
+                error,
+                "Timeout",
+                {
+                    "description": "Message processing timed out",
+                    "code": ERROR_CODES.MESSAGE.TIMEOUT,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def execution_failed(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.MESSAGE,
+                error,
+                "Execution failed",
+                {
+                    "description": "Failed to execute message",
+                    "code": ERROR_CODES.MESSAGE.EXECUTION_FAILED,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def internal_error(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.MESSAGE,
+                error,
+                "Internal error",
+                {
+                    "description": "Internal error occurred",
+                    "code": ERROR_CODES.MESSAGE.INTERNAL_ERROR,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+    class cluster:
+        @staticmethod
+        def join_failed(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.CLUSTER,
+                error,
+                "Join failed",
+                {
+                    "description": "Failed to join cluster",
+                    "code": ERROR_CODES.CLUSTER.JOIN_FAILED,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def sync_failed(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.CLUSTER,
+                error,
+                "Sync failed",
+                {
+                    "description": "Failed to sync cluster state",
+                    "code": ERROR_CODES.CLUSTER.SYNC_FAILED,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def communication_failed(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.CLUSTER,
+                error,
+                "Communication failed",
+                {
+                    "description": "Failed to communicate with cluster",
+                    "code": ERROR_CODES.CLUSTER.COMMUNICATION_FAILED,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def invalid_state(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.CLUSTER,
+                error,
+                "Invalid state",
+                {
+                    "description": "Cluster is in an invalid state",
+                    "code": ERROR_CODES.CLUSTER.INVALID_STATE,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def node_not_found(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.CLUSTER,
+                error,
+                "Node not found",
+                {
+                    "description": "Requested node could not be found",
+                    "code": ERROR_CODES.CLUSTER.NODE_NOT_FOUND,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def instance_not_found(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.CLUSTER,
+                error,
+                "Requested instance not found",
+                {
+                    "description": "Requested instance could not be found",
+                    "code": ERROR_CODES.CLUSTER.INSTANCE_NOT_FOUND,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def internal_error(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.CLUSTER,
+                error,
+                "Internal error",
+                {
+                    "description": "Internal error occurred",
+                    "code": ERROR_CODES.CLUSTER.INTERNAL_ERROR,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+    class registry:
+        @staticmethod
+        def internal_error(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.REGISTRY,
+                error,
+                "Internal error",
+                {
+                    "description": "Internal error occurred",
+                    "code": ERROR_CODES.REGISTRY.INTERNAL_ERROR,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+    class rpc:
+        @staticmethod
+        def method_not_found(
+            method: str, error: Any, details: ErrorDetailsPartial | None = None
+        ) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.RPC,
+                error,
+                f"Method not found: {method}",
+                {
+                    "description": "Requested method could not be found",
+                    "code": ERROR_CODES.RPC.METHOD_NOT_FOUND,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def invalid_request(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.RPC,
+                error,
+                "Invalid request",
+                {
+                    "description": "Invalid request received",
+                    "code": ERROR_CODES.RPC.INVALID_REQUEST,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def request_failed(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.RPC,
+                error,
+                "RPC request failed",
+                {
+                    "description": "Failed to send RPC request",
+                    "code": ERROR_CODES.RPC.INTERNAL_ERROR,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def execution_failed(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.RPC,
+                error,
+                "RPC execution failed",
+                {
+                    "description": "Failed to execute RPC request",
+                    "code": ERROR_CODES.RPC.INTERNAL_ERROR,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def internal_error(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.RPC,
+                error,
+                "Internal error",
+                {
+                    "description": "Internal error occurred",
+                    "code": ERROR_CODES.RPC.INTERNAL_ERROR,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+        @staticmethod
+        def connection_failed(error: Any, details: ErrorDetailsPartial | None = None) -> NatsError:
+            return ErrorFactory.create(
+                ErrorType.RPC,
+                error,
+                "Connection failed",
+                {
+                    "description": "Failed to establish connection",
+                    "code": ERROR_CODES.RPC.CONNECTION_FAILED,
+                    **(details or {}),  # type: ignore
+                },
+            )
+
+    @staticmethod
+    async def handle(
+        operation: Callable[[], Awaitable[Any]], type_: ErrorType, message: str, details: ErrorDetails
+    ) -> Any:
+        try:
+            return await operation()
+        except Exception as error:
+            raise ErrorFactory.create(type_, error, message, details) from error
+
+
+# Utils
+def sanitize_details(details: ErrorDetails) -> ErrorDetails:
+    def convert_value(value: Any) -> Any:
+        if isinstance(value, (bytes, bytearray, memoryview)):
+            return "<binary>"
+        elif isinstance(value, dict):
+            value = cast(dict[str, Any], value)
+            return {k: convert_value(v) for k, v in value.items()}
+        elif isinstance(value, list):
+            value = cast(list[Any], value)
+            return [convert_value(v) for v in value]
+        return value
+
+    return convert_value(details or {})