lmcache-cli 0.4.5.dev0__py3-none-any.whl

lmcache/v1/config_base.py

@@ -0,0 +1,848 @@
+# SPDX-License-Identifier: Apache-2.0
+"""
+LMCache Configuration Base Module
+
+This module provides common configuration utilities and base classes
+for all LMCache configuration systems to avoid code duplication.
+"""
+
+# Standard
+from dataclasses import make_dataclass
+from typing import Any, Callable, Dict, Optional, Protocol, Union
+import ast
+import json
+import os
+import threading
+import uuid
+
+# Third Party
+import requests
+import yaml
+
+# First Party
+from lmcache.logging import init_logger
+
+logger = init_logger(__name__)
+
+
+def _apply_env_converter_safely(config_definitions, name, value):
+    """Apply env_converter to a value safely."""
+    if name not in config_definitions:
+        return value
+
+    config = config_definitions[name]
+    env_converter = config.get("env_converter")
+    if env_converter:
+        try:
+            # Don't apply converter if value is None
+            if value is None:
+                return None
+            return env_converter(value)
+        except (ValueError, json.JSONDecodeError) as e:
+            log_message = f"Failed to convert value for {name}={value!r}: {e}"
+            logger.warning(log_message)
+            # Return None if conversion fails
+            return None
+    return value
+
+
+# Common configuration parsing utilities
+def _parse_local_disk(local_disk) -> Optional[str]:
+    """Parse local disk path configuration.
+
+    Accepts a single path or comma-separated paths, each optionally
+    prefixed with ``file://``.  Returns a comma-joined string of bare
+    directory paths suitable for ``LocalDiskBackend``.
+
+    Examples::
+
+        "file:///mnt/nvme0/"              -> "/mnt/nvme0/"
+        "/mnt/nvme0/,/mnt/nvme1/"         -> "/mnt/nvme0/,/mnt/nvme1/"
+        "file:///mnt/nvme0/,file:///mnt/nvme1/"
+                                           -> "/mnt/nvme0/,/mnt/nvme1/"
+
+    Args:
+        local_disk: Raw config value — ``None``, a single path, or
+            comma-separated paths.
+
+    Returns:
+        Comma-joined bare directory paths, or ``None`` if disabled.
+    """
+    if local_disk is None:
+        return None
+
+    raw_parts = [p.strip() for p in str(local_disk).split(",") if p.strip()]
+    if not raw_parts:
+        return None
+
+    parsed: list[str] = []
+    for part in raw_parts:
+        if part.startswith("file://"):
+            parsed.append(part[7:])
+        else:
+            parsed.append(part)
+
+    return ",".join(parsed)
+
+
+def _to_int_list(
+    value: Optional[Union[str, int, list[Any]]],
+) -> Optional[list[int]]:
+    """Convert value to list of integers"""
+    if value is None:
+        return None
+    if isinstance(value, list):
+        return [int(x) for x in value]
+    if isinstance(value, int):
+        return [value]
+    parts = [p.strip() for p in str(value).split(",") if p.strip()]
+    return [int(p) for p in parts]
+
+
+def _to_float_list(
+    value: Optional[Union[str, float, list[Any]]],
+) -> Optional[list[float]]:
+    """Convert value to list of floats"""
+    if value is None:
+        return None
+    if isinstance(value, list):
+        return [float(x) for x in value]
+    if isinstance(value, float):
+        return [value]
+    parts = [p.strip() for p in str(value).split(",") if p.strip()]
+    return [float(p) for p in parts]
+
+
+def _to_str_list(
+    value: Optional[Union[str, list[str]]],
+) -> Optional[list[str]]:
+    """Convert value to list of strings"""
+    if value is None:
+        return None
+    if isinstance(value, list):
+        return value
+    parts = [p.strip() for p in value.split(",") if p.strip()]
+    return [p for p in parts]
+
+
+def _to_bool(
+    value: Optional[Union[bool, int, str]],
+) -> bool:
+    """Convert value to boolean"""
+    if isinstance(value, bool):
+        return value
+    return str(value).strip().lower() in ["true", "1"]
+
+
+def _parse_quoted_string(value: str) -> str:
+    """Parse a string that may be surrounded by quotes and handle escape characters.
+
+    Args:
+        value: The input string that may be quoted
+
+    Returns:
+        The unquoted string with escape characters properly handled
+    """
+    if not value:
+        return value
+
+    value = value.strip()
+
+    if len(value) >= 2 and value[0] == value[-1] and value[0] in ("'", '"'):
+        try:
+            evaluated = ast.literal_eval(value)
+            if isinstance(evaluated, str):
+                return evaluated
+        except (ValueError, SyntaxError):
+            # If ast.literal_eval fails, it's not a valid Python literal.
+            # Fall back to simply stripping the outer quotes.
+            return value[1:-1]
+
+    return value
+
+
+def _to_json(obj: Any) -> str:
+    """Convert object to JSON string"""
+    # If object has to_dict method, use it to convert to dict first
+    if hasattr(obj, "to_dict"):
+        return json.dumps(obj.to_dict(), indent=2)
+    # Otherwise try to serialize directly
+    return json.dumps(obj, indent=2)
+
+
+def _from_json(cls, json_str: str):
+    """Deserialize a JSON string into a configuration object."""
+    try:
+        config_dict = json.loads(json_str)
+        return cls.from_dict(config_dict)
+    except json.JSONDecodeError as e:
+        logger.error(f"Invalid JSON input: {e}")
+        raise
+
+
+# Configuration aliases and deprecated mappings utility
+def _resolve_config_aliases(
+    config_dict: dict,
+    source: str,
+    config_definitions: dict,
+    config_aliases: dict,
+    deprecated_configs: dict,
+) -> dict:
+    """Resolve configuration aliases and handle deprecated configurations."""
+    resolved = {}
+
+    # Process each key in the input
+    for key, value in config_dict.items():
+        if key in deprecated_configs:
+            # Log deprecation warning
+            logger.warning(f"{deprecated_configs[key]} (source: {source})")
+
+            # Map to new key if alias exists
+            if key in config_aliases:
+                new_key = config_aliases[key]
+                resolved[new_key] = value
+            else:
+                # Keep deprecated key for backward compatibility
+                resolved[key] = value
+        elif key in config_definitions:
+            # Valid configuration key
+            resolved[key] = value
+        else:
+            # Unknown configuration key
+            logger.warning(f"Unknown configuration key: {key} (source: {source})")
+
+    return resolved
+
+
+# Base configuration class creator
+def create_config_class(
+    config_name: str,
+    config_definitions: dict[str, dict[str, Any]],
+    config_aliases: Optional[dict[str, str]] = None,
+    deprecated_configs: Optional[dict[str, str]] = None,
+    namespace_extras: Optional[dict[str, Any]] = None,
+    env_prefix: str = "LMCACHE_",
+):
+    """Create a configuration class dynamically with common functionality.
+
+    Args:
+        config_name: Name of the configuration class
+        config_definitions: Dictionary of configuration definitions
+        config_aliases: Optional mapping of deprecated names to current names
+        deprecated_configs: Optional mapping of deprecated names to warning messages
+        namespace_extras: Optional additional namespace items for the class
+        env_prefix: Environment variable prefix (default: "LMCACHE_")
+
+    Returns:
+        A dynamically created dataclass with configuration functionality
+    """
+    # Default values
+    config_aliases = config_aliases or {}
+    deprecated_configs = deprecated_configs or {}
+    namespace_extras = namespace_extras or {}
+
+    # Extract fields from configuration definitions
+    fields_dict = {}
+    for name, config in config_definitions.items():
+        fields_dict[name] = (config["type"], config["default"])
+
+    def _post_init(self):
+        """Post-initialization setup"""
+        # Initialize user-set keys tracking set
+        # This tracks which config keys were explicitly set by user
+        # (via file, env vars, or overrides) vs. using default values
+        if not hasattr(self, "_user_set_keys"):
+            object.__setattr__(self, "_user_set_keys", set())
+        # Generate instance ID if not set
+        if not getattr(self, "lmcache_instance_id", None):
+            self.lmcache_instance_id = f"{config_name.lower()}_{uuid.uuid4().hex}"
+
+    def _from_env(cls):
+        """Load configuration from environment variables"""
+
+        def get_env_name(attr_name: str) -> str:
+            return f"{env_prefix}{attr_name.upper()}"
+
+        # Collect all defined and deprecated env vars
+        all_keys = list(config_definitions.keys()) + list(config_aliases.keys())
+        env_config = {}
+        for name in all_keys:
+            env_name = get_env_name(name)
+            env_value = os.getenv(env_name)
+            if env_value is not None:
+                env_config[name] = env_value
+
+        # Resolve aliases and handle deprecated configurations
+        resolved_config = _resolve_config_aliases(
+            env_config,
+            "environment variables",
+            config_definitions,
+            config_aliases,
+            deprecated_configs,
+        )
+
+        config_values = {}
+        user_set_keys = set()  # Track keys explicitly set by user
+        for name, config in config_definitions.items():
+            if name in resolved_config:
+                try:
+                    raw_value = resolved_config[name]
+                    value = _parse_quoted_string(raw_value)
+                    # Apply env_converter safely
+                    config_values[name] = _apply_env_converter_safely(
+                        config_definitions, name, value
+                    )
+                    user_set_keys.add(name)  # Mark as user-set
+                except (ValueError, json.JSONDecodeError) as e:
+                    raw_value_for_log = resolved_config.get(name, "unknown value")
+                    log_message = (
+                        f"Failed to parse {get_env_name(name)}"
+                        f"={raw_value_for_log!r}: {e}"
+                    )
+                    logger.warning(log_message)
+                    # Use default value with conversion
+                    config_values[name] = _apply_env_converter_safely(
+                        config_definitions, name, config["default"]
+                    )
+            else:
+                # Use default value with conversion
+                config_values[name] = _apply_env_converter_safely(
+                    config_definitions, name, config["default"]
+                )
+
+        instance = cls(**config_values)
+        # Store user-set keys in the instance
+        object.__setattr__(instance, "_user_set_keys", user_set_keys)
+        return instance
+
+    def _from_file(cls, file_path: str):
+        """Load configuration from file"""
+        with open(file_path, "r") as fin:
+            file_config = yaml.safe_load(fin) or {}
+
+        # Resolve aliases and handle deprecated configurations
+        resolved_config = _resolve_config_aliases(
+            file_config,
+            f"file: {file_path}",
+            config_definitions,
+            config_aliases,
+            deprecated_configs,
+        )
+
+        config_values = {}
+        user_set_keys = set()  # Track keys explicitly set by user
+        for name, config in config_definitions.items():
+            if name in resolved_config:
+                value = resolved_config[name]
+                user_set_keys.add(name)  # Mark as user-set
+            else:
+                value = config["default"]
+            # Apply env_converter safely regardless of whether value is None or not
+            config_values[name] = _apply_env_converter_safely(
+                config_definitions, name, value
+            )
+
+        instance = cls(**config_values)
+        # Store user-set keys in the instance
+        object.__setattr__(instance, "_user_set_keys", user_set_keys)
+        return instance
+
+    def _from_defaults(cls, **kwargs):
+        """Create configuration from defaults"""
+        config_values = {}
+        user_set_keys = set()  # Track keys explicitly set by user
+        for name, config in config_definitions.items():
+            if name in kwargs:
+                value = kwargs[name]
+                user_set_keys.add(name)  # Mark as user-set
+            else:
+                value = config["default"]
+            # Apply env_converter safely regardless of whether value is None or not
+            config_values[name] = _apply_env_converter_safely(
+                config_definitions, name, value
+            )
+
+        instance = cls(**config_values)
+        # Store user-set keys in the instance
+        object.__setattr__(instance, "_user_set_keys", user_set_keys)
+        return instance
+
+    def _update_config_from_env(self):
+        """Update an existing config object with environment variable configurations."""
+
+        def get_env_name(attr_name: str) -> str:
+            return f"{env_prefix}{attr_name.upper()}"
+
+        env_config = {}
+        # Collect all defined and deprecated env vars
+        all_keys = list(config_definitions.keys()) + list(config_aliases.keys())
+        for name in all_keys:
+            env_name = get_env_name(name)
+            env_value = os.getenv(env_name)
+            if env_value is not None:
+                env_config[name] = env_value
+
+        # Resolve aliases
+        resolved_config = _resolve_config_aliases(
+            env_config,
+            "environment variables",
+            config_definitions,
+            config_aliases,
+            deprecated_configs,
+        )
+
+        # Ensure _user_set_keys exists
+        if not hasattr(self, "_user_set_keys"):
+            object.__setattr__(self, "_user_set_keys", set())
+
+        # Update config object
+        for name, config in config_definitions.items():
+            if name in resolved_config:
+                try:
+                    raw_value = resolved_config[name]
+                    value = _parse_quoted_string(raw_value)
+                    converted_value = config["env_converter"](value)
+                    setattr(self, name, converted_value)
+                    # Mark as user-set
+                    self._user_set_keys.add(name)
+                except (ValueError, json.JSONDecodeError) as e:
+                    raw_value_for_log = resolved_config.get(name, "unknown value")
+                    log_message = (
+                        f"Failed to parse {get_env_name(name)}"
+                        f"={raw_value_for_log!r}: {e}"
+                    )
+                    logger.warning(log_message)
+
+        return self
+
+    def _from_dict(cls, config_dict: dict):
+        """Create configuration from a dictionary."""
+        resolved_config = _resolve_config_aliases(
+            config_dict,
+            "dictionary input",
+            config_definitions,
+            config_aliases,
+            deprecated_configs,
+        )
+        config_values = {}
+        user_set_keys = set()  # Track keys explicitly set by user
+        for name, config in config_definitions.items():
+            if name in resolved_config:
+                value = resolved_config[name]
+                user_set_keys.add(name)  # Mark as user-set
+            else:
+                value = config["default"]
+            if value is not None:
+                value = config["env_converter"](value)
+            config_values[name] = value
+        instance = cls(**config_values)
+        # Store user-set keys in the instance
+        object.__setattr__(instance, "_user_set_keys", user_set_keys)
+        return instance
+
+    def _to_dict(self):
+        """Convert the configuration object into a dictionary."""
+        return {name: getattr(self, name) for name in config_definitions}
+
+    # Build namespace
+    namespace = {
+        "__post_init__": _post_init,
+        "from_defaults": classmethod(_from_defaults),
+        "from_file": classmethod(_from_file),
+        "from_env": classmethod(_from_env),
+        "update_config_from_env": _update_config_from_env,
+        "from_dict": classmethod(_from_dict),
+        "to_dict": _to_dict,
+        "to_json": _to_json,
+        "from_json": classmethod(_from_json),
+        "__str__": lambda self: str(
+            {name: getattr(self, name) for name in config_definitions}
+        ),
+    }
+
+    # Add extra namespace items
+    namespace.update(namespace_extras)
+
+    # Create class
+    cls = make_dataclass(
+        config_name,
+        [(name, type_, default) for name, (type_, default) in fields_dict.items()],
+        namespace=namespace,
+    )
+
+    # Add config_definitions as a class attribute for accessing converters
+    cls._config_definitions = config_definitions  # type: ignore[attr-defined]
+
+    return cls
+
+
+# Thread-safe singleton utility
+class SingletonGetter(Protocol):
+    """Protocol for singleton getter functions"""
+
+    def __call__(self) -> Any: ...
+
+    reset: Callable[[], None]
+
+
+def create_singleton_config(
+    getter_func_name: str,
+    config_class,
+    config_env_var: str = "LMCACHE_CONFIG_FILE",
+) -> SingletonGetter:
+    """Create thread-safe singleton configuration access pattern.
+
+    Args:
+        getter_func_name: Name for the singleton getter function
+        config_class: The configuration class to create singleton for
+        config_env_var: Environment variable name for configuration file path
+    """
+
+    _config_instance = None
+    _config_lock = threading.Lock()
+
+    def get_or_create_config() -> config_class:
+        """Get the configuration singleton"""
+        nonlocal _config_instance
+
+        # Double-checked locking for thread-safe singleton
+        if _config_instance is None:
+            with _config_lock:
+                if _config_instance is None:  # Check again within lock
+                    if config_env_var not in os.environ:
+                        logger.warning(
+                            "No configuration file is set. Trying to read "
+                            "configurations from the environment variables."
+                        )
+                        logger.warning(
+                            f"You can set the configuration file through "
+                            f"the environment variable: {config_env_var}"
+                        )
+                        _config_instance = config_class.from_env()
+                    else:
+                        config_file = os.environ[config_env_var]
+                        logger.info(f"Loading config file {config_file}")
+                        _config_instance = config_class.from_file(config_file)
+                        # Update config from environment variables
+                        _config_instance.update_config_from_env()
+
+        return _config_instance
+
+    def reset_config_instance() -> None:
+        """Reset the configuration singleton for testing"""
+        nonlocal _config_instance
+        with _config_lock:
+            _config_instance = None
+
+    # Set the function name for better debugging
+    get_or_create_config.__name__ = getter_func_name
+    get_or_create_config.reset = reset_config_instance  # type: ignore[attr-defined]
+
+    return get_or_create_config  # type: ignore[return-value]
+
+
+def load_config_with_overrides(
+    config_class,
+    config_file_env_var: str = "LMCACHE_CONFIG_FILE",
+    config_file_path: Optional[str] = None,
+    overrides: Optional[Dict[str, Any]] = None,
+):
+    """
+    Load configuration with support for file, environment variables, and overrides.
+
+    This is a generic utility function that can be reused across different
+    configuration classes (LMCacheEngineConfig, ControllerConfig, etc.)
+
+    Args:
+        config_class: The configuration class to instantiate
+        config_file_env_var: Environment variable name for config file path
+        config_file_path: Optional direct config file path (overrides env var)
+        overrides: Optional dictionary of configuration overrides
+
+    Returns:
+        Loaded and validated configuration instance
+    """
+    # Load configuration from file or environment
+    actual_config_path = config_file_path or os.getenv(config_file_env_var)
+
+    if actual_config_path:
+        logger.info("Loading config file: %s", actual_config_path)
+        config = config_class.from_file(actual_config_path)
+        # Allow environment variables to override file settings
+        config.update_config_from_env()
+    else:
+        logger.info("No config file specified, loading from environment variables.")
+        config = config_class.from_env()
+
+    # Apply any overrides
+    if overrides:
+        for key, value in overrides.items():
+            if hasattr(config, key):
+                old_value = getattr(config, key)
+
+                # Check if this configuration class has definitions with converters
+                if (
+                    hasattr(config, "_config_definitions")
+                    and key in config._config_definitions
+                ):
+                    # Use the global helper function to safely apply env_converter
+                    new_value = _apply_env_converter_safely(
+                        config._config_definitions, key, value
+                    )
+                    setattr(config, key, new_value)
+                else:
+                    setattr(config, key, value)
+
+                new_value = getattr(config, key)
+                if old_value != new_value:
+                    logger.info(
+                        "Override config: %s = %s (was %s)", key, new_value, old_value
+                    )
+            else:
+                logger.warning("Unknown config key: %s, ignoring", key)
+
+    # Validate configuration
+    if hasattr(config, "validate"):
+        config.validate()
+
+    # Log configuration
+    if hasattr(config, "log_config"):
+        config.log_config()
+
+    return config
+
+
+def parse_command_line_extra_params(extra_args: list[str]) -> dict[str, Any]:
+    """
+    Parse extra command-line parameters in key=value format.
+
+    Args:
+        extra_args: List of strings in format "key=value"
+
+    Returns:
+        Dictionary of parsed parameters
+    """
+    params = {}
+    for arg in extra_args:
+        if "=" in arg:
+            key, value = arg.split("=", 1)
+            key = key.lstrip("-")
+            try:
+                if value.lower() in ("true", "false"):
+                    params[key] = value.lower() == "true"
+                elif value.isdigit():
+                    params[key] = int(value)  # type: ignore[assignment]
+                elif value.replace(".", "", 1).isdigit():
+                    params[key] = float(value)  # type: ignore[assignment]
+                else:
+                    params[key] = value  # type: ignore[assignment]
+            except ValueError:
+                params[key] = value  # type: ignore[assignment]
+            logger.info("Extra parameter: %s = %s", key, params[key])
+    return params
+
+
+def validate_and_set_config_value(config, config_key, value, override: bool = True):
+    """Validate and set configuration value.
+
+    Args:
+        config: Configuration object to update.
+        config_key: The configuration key to set.
+        value: The value to set.
+        override: If True, completely replace the value. If False:
+            - For 'extra_config': merge with existing dict (new values take
+              precedence for conflicting keys).
+            - For other keys: skip if key was user-set.
+            Default is True.
+
+    Returns:
+        True if the value was set successfully, False otherwise.
+    """
+    if not hasattr(config, config_key):
+        logger.warning("Config key '%s' does not exist in configuration", config_key)
+        return False
+
+    try:
+        # Apply type conversion using env_converter if available
+        # Skip for extra_config which has special handling below
+        if hasattr(config, "_config_definitions") and config_key != "extra_config":
+            original_value = value
+            value = _apply_env_converter_safely(
+                config._config_definitions, config_key, value
+            )
+            # If original value was not None but conversion returned None,
+            # it means conversion failed
+            if original_value is not None and value is None:
+                # _apply_env_converter_safely already logged warning
+                return False
+
+        # Convert string to dict for extra_config
+        if config_key == "extra_config" and isinstance(value, str):
+            value = json.loads(value) if value else None
+
+        # Handle extra_config special logic
+        if config_key == "extra_config":
+            current_value = getattr(config, config_key, None)
+
+            # Handle None or empty value when override=False
+            if not override and (value is None or value == ""):
+                # Keep current value
+                logger.info(
+                    "Keeping current extra_config (override=False, value is None/empty)"
+                )
+                return True
+
+            if override:
+                # Full override: replace current value with new value
+                setattr(config, config_key, value)
+                logger.info("Overridden extra_config")
+                return True
+            else:
+                # Merge mode (override=False)
+                if value is not None and isinstance(value, dict):
+                    if current_value is not None and isinstance(current_value, dict):
+                        # Merge: current values preserved, new values override
+                        merged_value = {**current_value, **value}
+                        setattr(config, config_key, merged_value)
+                        logger.info("Merged extra_config")
+                    else:
+                        # Current value is None or not a dict, set new value
+                        setattr(config, config_key, value)
+                        logger.info("Set extra_config")
+                return True
+
+        # For non-extra_config keys: skip if override=False and key user-set
+        if not override:
+            user_set_keys: set[str] = getattr(config, "_user_set_keys", set())
+            if config_key in user_set_keys:
+                current_value = getattr(config, config_key, None)
+                logger.info(
+                    "Skipping config %s (override=False, user-set value=%s)",
+                    config_key,
+                    current_value,
+                )
+                # Return True to indicate operation completed (kept existing)
+                return True
+
+        setattr(config, config_key, value)
+        logger.info("Set config item '%s'", config_key)
+        return True
+    except Exception as e:
+        logger.error(
+            "Failed to set config item '%s' with value %s: %s",
+            config_key,
+            value,
+            e,
+        )
+        return False
+
+
+def fetch_remote_config(
+    remote_config_url: str,
+    app_id: Optional[str],
+    config: Any,
+    timeout: int = 10,
+) -> Optional[dict]:
+    """Fetch configuration from remote config service.
+
+    The config server protocol:
+    - Request: POST with JSON body containing 'current_config' and 'env_variables'
+    - Query parameter: 'appId' if app_id is provided
+    - Response: JSON with 'configs' array, each item has 'key', 'value', 'override'
+
+    See examples/remote_config_server/ for a reference implementation.
+
+    Args:
+        remote_config_url: URL of the remote config service.
+        app_id: Optional app ID to send to the config service.
+        config: Current LMCacheEngineConfig to send to the config service.
+        timeout: Request timeout in seconds.
+
+    Returns:
+        Parsed JSON response from the config service, or None if failed.
+    """
+    try:
+        # Build request payload with current config and env variables
+        payload: dict[str, Any] = {
+            "current_config": config.to_dict(),
+            "env_variables": {k: v for k, v in os.environ.items()},
+        }
+
+        # Build URL with app_id query parameter if provided
+        params = {"appId": app_id} if app_id else None
+
+        # Send POST request with JSON payload
+        response = requests.get(
+            remote_config_url,
+            json=payload,
+            params=params,
+            headers={"Content-Type": "application/json"},
+            timeout=timeout,
+        )
+        response.raise_for_status()
+        return response.json()
+
+    except requests.RequestException as e:
+        logger.warning(
+            "Failed to fetch remote config from %s: %s", remote_config_url, e
+        )
+        return None
+    except json.JSONDecodeError as e:
+        logger.warning("Failed to parse remote config response: %s", e)
+        return None
+    except Exception as e:
+        logger.warning("Unexpected error fetching remote config: %s", e)
+        return None
+
+
+def apply_remote_configs(config: Any, remote_response: dict) -> Any:
+    """Apply remote configuration to LMCacheEngineConfig.
+
+    This function extracts the 'configs' field from the remote response
+    and applies each config item to the LMCacheEngineConfig instance.
+
+    The expected format of remote_response['configs'] is:
+    [
+        {"override": true, "key": "config_key", "value": "config_value"},
+        ...
+    ]
+
+    Args:
+        config: LMCacheEngineConfig instance to update.
+        remote_response: Response from the remote config service.
+
+    Returns:
+        Updated LMCacheEngineConfig instance.
+    """
+    configs = remote_response.get("configs", [])
+    if not configs:
+        logger.info("No configs found in remote response")
+        return config
+
+    applied_count = 0
+    for config_item in configs:
+        if not isinstance(config_item, dict):
+            logger.warning("Invalid config item format: %s", config_item)
+            continue
+
+        key = config_item.get("key")
+        value = config_item.get("value")
+        override = config_item.get("override", True)
+
+        if not key:
+            logger.warning("Config item missing 'key': %s", config_item)
+            continue
+
+        # Try to convert value to appropriate type
+        if validate_and_set_config_value(config, key, value, override=override):
+            logger.info("Applied remote config: %s=%s", key, value)
+            applied_count += 1
+        else:
+            logger.warning(
+                "Failed to apply remote config %s=%s. Using default value.",
+                key,
+                value,
+            )
+
+    logger.info("Applied %d remote configuration items", applied_count)
+    return config