refactor(config,cli,sdk): remove ConfigurationPort provider_name and provider_type overrides

Delete override_provider_name(), override_provider_type(),
get_active_provider_name_override(), and get_active_provider_type_override()
from ConfigurationPort, ConfigurationManager, and ConfigurationAdapter.

CLI main.py: remove the two container.get(ConfigurationPort) blocks that
called the now-deleted override methods. The args.provider_name and
args.provider_type values already flow end-to-end through Input DTOs.

SDK client.py: remove the initialize() block that called override_provider_type
and override_provider_name on the config port. SDKConfig.provider_name /
provider_type already reach Input DTOs via the existing pattern in each
explicit SDK method (e.g. provider_name=kwargs.get("provider_name") or
self._config.provider_name).

Tests for the deleted methods removed; docstring stale references updated.

Author: fgogolli

src/orb/application/queries/provider_handlers.py

@@ -57,27 +57,22 @@ async def execute_query(self, query: GetProviderHealthQuery) -> dict[str, Any]:
             provider_name = query.provider_name
             if not provider_name:
                 try:
-                    selection_result = self._provider_registry_service.select_active_provider()
-                    candidate_name = selection_result.provider_name
-                    # When provider_type is set, only return health if types match
-                    if query.provider_type:
-                        candidate_type = getattr(selection_result, "provider_type", None)
-                        if candidate_type and candidate_type != query.provider_type:
-                            return {
-                                "provider_name": None,
-                                "status": "not_found",
-                                "health": "unknown",
-                                "message": f"No active provider of type '{query.provider_type}' found",
-                            }
-                    provider_name = candidate_name
+                    selection_result = self._provider_registry_service.select_active_provider(
+                        provider_type=query.provider_type,
+                    )
+                    provider_name = selection_result.provider_name
                     self.logger.debug("Using active provider: %s", provider_name)
                 except Exception as e:
                     self.logger.warning("Failed to get active provider: %s", e, exc_info=True)
                     return {
                         "provider_name": None,
                         "status": "not_found",
                         "health": "unknown",
-                        "message": "No active provider found",
+                        "message": (
+                            f"No active provider of type '{query.provider_type}' found"
+                            if query.provider_type
+                            else "No active provider found"
+                        ),
                     }
 
             # Get health information from registry service

src/orb/cli/main.py

@@ -125,28 +125,6 @@ async def main() -> None:
             except Exception as e:
                 logger.warning("Failed to override scheduler strategy: %s", e, exc_info=True)
 
-        if hasattr(args, "provider_name") and args.provider_name:
-            try:
-                from orb.domain.base.ports.configuration_port import ConfigurationPort
-                from orb.infrastructure.di.container import get_container
-
-                container = get_container()
-                config = container.get(ConfigurationPort)
-                config.override_provider_name(args.provider_name)
-            except Exception as e:
-                logger.warning("Failed to override provider name: %s", e, exc_info=True)
-
-        if hasattr(args, "provider_type") and args.provider_type:
-            try:
-                from orb.domain.base.ports.configuration_port import ConfigurationPort
-                from orb.infrastructure.di.container import get_container
-
-                container = get_container()
-                config = container.get(ConfigurationPort)
-                config.override_provider_type(args.provider_type)
-            except Exception as e:
-                logger.warning("Failed to override provider type: %s", e, exc_info=True)
-
         # Skip application initialization for init command
         if args.resource == "init":
             from orb.interface.init_command_handler import handle_init

src/orb/config/managers/configuration_manager.py

@@ -73,8 +73,6 @@ def __init__(
 
         # Scheduler override support
         self._scheduler_override: Optional[str] = None
-        self._provider_name_override: Optional[str] = None
-        self._provider_type_override: Optional[str] = None
 
     @property
     def loader(self) -> ConfigurationLoader:
@@ -283,22 +281,6 @@ def restore_scheduler_strategy(self) -> None:
         """Restore original scheduler strategy."""
         self._scheduler_override = None
 
-    def override_provider_name(self, provider_name: str) -> None:
-        """Temporarily override provider instance by exact name."""
-        self._provider_name_override = provider_name
-
-    def override_provider_type(self, provider_type: str) -> None:
-        """Temporarily restrict selection to a provider type."""
-        self._provider_type_override = provider_type
-
-    def get_active_provider_name_override(self) -> Optional[str]:
-        """Get current provider name override."""
-        return self._provider_name_override
-
-    def get_active_provider_type_override(self) -> Optional[str]:
-        """Get current provider type override."""
-        return self._provider_type_override
-
     def get_loaded_config_file(self) -> str | None:
         """Get the actual config file that was loaded."""
         # If a config file path is already stored (set in __init__ or reload), use it

src/orb/domain/base/ports/configuration_port.py

@@ -71,22 +71,6 @@ def get_native_spec_config(self) -> dict[str, Any]:
     def get_metrics_config(self) -> dict[str, Any]:
         """Get metrics configuration."""
 
-    @abstractmethod
-    def get_active_provider_name_override(self) -> str | None:
-        """Get current provider name override from CLI (exact instance name)."""
-
-    @abstractmethod
-    def get_active_provider_type_override(self) -> str | None:
-        """Get current provider type override from CLI (type filter)."""
-
-    @abstractmethod
-    def override_provider_name(self, provider_name: str) -> None:
-        """Override the active provider by exact instance name."""
-
-    @abstractmethod
-    def override_provider_type(self, provider_type: str) -> None:
-        """Restrict selection to a provider type."""
-
     # get_provider_instance_config inherited from ProviderConfigPort
 
     @abstractmethod

src/orb/infrastructure/adapters/configuration_adapter.py

@@ -380,14 +380,6 @@ def override_scheduler_strategy(self, strategy: str) -> None:  # type: ignore[ov
         """Override scheduler strategy - delegate to ConfigurationManager."""
         self._config_manager.override_scheduler_strategy(strategy)
 
-    def override_provider_name(self, provider_name: str) -> None:
-        """Override provider instance by exact name - delegate to ConfigurationManager."""
-        self._config_manager.override_provider_name(provider_name)
-
-    def override_provider_type(self, provider_type: str) -> None:
-        """Restrict selection to a provider type - delegate to ConfigurationManager."""
-        self._config_manager.override_provider_type(provider_type)
-
     def get_resource_prefix(self, resource_type: str) -> str:
         """Get resource naming prefix for the given resource type."""
         try:
@@ -401,14 +393,6 @@ def get_resource_prefix(self, resource_type: str) -> str:
             )
             return ""
 
-    def get_active_provider_name_override(self) -> str | None:
-        """Get current provider name override from CLI."""
-        return self._config_manager.get_active_provider_name_override()
-
-    def get_active_provider_type_override(self) -> str | None:
-        """Get current provider type override from CLI."""
-        return self._config_manager.get_active_provider_type_override()
-
     def get_configuration_value(self, key: str, default: Any = None) -> Any:
         """Get configuration value."""
         return self._config_manager.get(key, default)

src/orb/interface/infrastructure_command_handler.py

@@ -229,12 +229,10 @@ def _get_active_providers() -> List[Dict[str, Any]]:
 def _get_active_providers_with_overrides() -> List[Dict[str, Any]]:
     """Get active providers with provider-name and provider-type overrides applied.
 
-    The provider-name and provider-type overrides are already handled by the
-    caller via ``ConfigurationPort.get_active_provider_name_override()`` and
-    ``get_active_provider_type_override()``.  Provider-specific config key
-    overrides (e.g. AWS region, AWS profile) are not applied here because
-    they are provider-scoped and do not belong in the provider-agnostic
-    interface layer.
+    Provider-name and provider-type filtering is a per-operation concern handled
+    by each orchestrator's Input DTO.  Provider-specific config key overrides
+    (e.g. AWS region, AWS profile) are not applied here because they are
+    provider-scoped and do not belong in the provider-agnostic interface layer.
     """
     return _get_active_providers()
 

src/orb/sdk/client.py

@@ -12,7 +12,6 @@
 
 from orb.bootstrap import Application
 from orb.config.managers.configuration_manager import ConfigurationManager
-from orb.domain.base.ports.configuration_port import ConfigurationPort
 from orb.infrastructure.di.container import create_container
 
 from .config import SDKConfig
@@ -73,11 +72,12 @@ def __init__(
             app_config: Application config dict — replaces config.json on disk.
                         Pass the same structure as config.json to run without filesystem.
             scheduler: Scheduler strategy override (e.g. ``"default"`` or ``"hostfactory"``).
-            provider_type: Provider type filter applied via ConfigurationPort on initialise.
-                           Narrows which provider is selected when multiple providers are
-                           registered (e.g. ``"k8s"``).
-            provider_name: Provider instance name applied via ConfigurationPort on initialise.
-                           Selects a specific named provider instance (e.g. ``"my-k8s-cluster"``).
+            provider_type: Provider type filter. Narrows which provider is selected when
+                           multiple providers are registered (e.g. ``"k8s"``). Passed
+                           through to Input DTOs on each operation.
+            provider_name: Provider instance name. Selects a specific named provider
+                           instance (e.g. ``"my-k8s-cluster"``). Passed through to
+                           Input DTOs on each operation.
             provider_config: Provider-specific key/value pairs (e.g. ``{"region": "us-east-1"}``).
             region: **Deprecated.** Use ``provider_config={"region": ...}`` instead.
             profile: **Deprecated.** Use ``provider_config={"profile": ...}`` instead.
@@ -201,19 +201,6 @@ async def initialize(self) -> bool:
                     provider=self._config.provider,
                 )
 
-            # Apply provider-name and provider-type overrides from SDK config.
-            # Use self._container (the per-client isolated container), not the
-            # module-level singleton returned by get_container(), so that overrides
-            # from one ORBClient instance never bleed into another.
-            # provider_config is stored for future use; pushing arbitrary provider
-            # key/value pairs through a provider-agnostic port is a follow-up task.
-            if self._config.provider_type or self._config.provider_name:
-                config_port = self._container.get(ConfigurationPort)
-                if self._config.provider_type:
-                    config_port.override_provider_type(self._config.provider_type)
-                if self._config.provider_name:
-                    config_port.override_provider_name(self._config.provider_name)
-
             # Get CQRS buses directly from the initialized application
             self._query_bus = self._app.get_query_bus()
             self._command_bus = self._app.get_command_bus()

tests/unit/infrastructure/test_configuration_manager.py

@@ -217,24 +217,6 @@ def test_no_aws_prefixed_methods_on_configuration_manager(self, tmp_path):
             f"Found AWS-specific methods that should be renamed: {aws_methods}"
         )
 
-    def test_override_provider_name(self, tmp_path):
-        """Test overriding provider by exact instance name."""
-        config_file = tmp_path / "config.json"
-        config_file.write_text(json.dumps({}))
-
-        manager = ConfigurationManager(config_file=str(config_file))
-        manager.override_provider_name("aws-us-east-1")
-        assert manager.get_active_provider_name_override() == "aws-us-east-1"
-
-    def test_override_provider_type(self, tmp_path):
-        """Test overriding provider type filter."""
-        config_file = tmp_path / "config.json"
-        config_file.write_text(json.dumps({}))
-
-        manager = ConfigurationManager(config_file=str(config_file))
-        manager.override_provider_type("k8s")
-        assert manager.get_active_provider_type_override() == "k8s"
-
     def test_override_scheduler_strategy(self, tmp_path):
         """Test overriding scheduler strategy."""
         config_file = tmp_path / "config.json"

tests/unit/providers/test_provider_interface.py

@@ -58,16 +58,21 @@ def test_provider_configuration_validation(self):
         # Test base configuration
         config = ProviderConfig(provider_type="test")
         assert config.provider_type == "test"
-        assert config.region is None
 
-        # Test with region
-        config_with_region = ProviderConfig(provider_type="test", region="test-region")
-        assert config_with_region.region == "test-region"
+        # Test provider-specific fields flow through the opaque provider_config
+        # dict rather than a typed base-level field.
+        config_with_provider_config = ProviderConfig(
+            provider_type="test",
+            provider_config={"region": "test-region", "profile": "test-profile"},  # type: ignore[call-arg]
+        )
+        assert getattr(config_with_provider_config, "provider_config") == {
+            "region": "test-region",
+            "profile": "test-profile",
+        }
 
         # Test extra fields are allowed
         config_with_extras = ProviderConfig(
             provider_type="test",
-            region="test-region",
             custom_field="custom_value",  # type: ignore[call-arg]
         )
         assert getattr(config_with_extras, "custom_field") == "custom_value"

tests/unit/providers/test_provider_registry.py

@@ -399,9 +399,7 @@ def test_name_override_takes_precedence_over_type_override(self):
         aws2 = self._make_provider("aws-eu-west-1", "aws")
         registry = _make_registry_multi([aws1, aws2])
 
-        result = registry.select_active_provider(
-            provider_name="aws-eu-west-1", provider_type="aws"
-        )
+        result = registry.select_active_provider(provider_name="aws-eu-west-1", provider_type="aws")
 
         assert result.provider_name == "aws-eu-west-1"
         assert "name override" in result.selection_reason