refactor(core): consolidate action and plan definitions

artemis/llm/router.py

@@ -367,81 +367,3 @@ class ModelFactory:
             raise ValueError(f"Unsupported model provider: {provider}")
 
 
-class ModelRouter:
-    """Dynamic router mapping agent roles to primary and fallback model endpoints."""
-
-    def __init__(self, default_model: str = "gemini-2.5-flash"):
-        self.default_endpoint = ModelEndpoint(
-            provider=ModelProvider.GOOGLE,
-            model_name=default_model,
-        )
-        self._role_routes: dict[str, ModelEndpoint] = {}
-        self._fallback_routes: dict[str, list[ModelEndpoint]] = {}
-        self._setup_default_routes()
-
-    def _setup_default_routes(self) -> None:
-        """Initializes recommended role mappings."""
-        self._role_routes["planner"] = ModelEndpoint(
-            provider=ModelProvider.GOOGLE,
-            model_name="gemini-2.5-pro",
-            temperature=0.2,
-        )
-        self._role_routes["operator"] = ModelEndpoint(
-            provider=ModelProvider.GOOGLE,
-            model_name="gemini-2.5-flash",
-            temperature=0.0,
-        )
-        self._role_routes["validator"] = ModelEndpoint(
-            provider=ModelProvider.GOOGLE,
-            model_name="gemini-2.5-pro",
-            temperature=0.1,
-        )
-        self._role_routes["summarizer"] = ModelEndpoint(
-            provider=ModelProvider.GOOGLE,
-            model_name="gemini-2.5-flash",
-            temperature=0.0,
-        )
-        self._fallback_routes["planner"] = [
-            ModelEndpoint(provider=ModelProvider.GOOGLE, model_name="gemini-2.5-flash"),
-        ]
-
-    def set_role_route(
-        self,
-        role: str,
-        endpoint: ModelEndpoint | str,
-        fallbacks: list[ModelEndpoint] | None = None,
-    ) -> None:
-        """Configures or overrides a route for a specific agent role."""
-        if isinstance(endpoint, str):
-            endpoint = ModelEndpoint(model_name=endpoint)
-        self._role_routes[role.lower()] = endpoint
-        if fallbacks is not None:
-            self._fallback_routes[role.lower()] = fallbacks
-
-    def get_endpoint(self, role: str) -> ModelEndpoint:
-        """Retrieves the configured primary model endpoint for a role."""
-        return self._role_routes.get(role.lower(), self.default_endpoint)
-
-    def get_fallbacks(self, role: str) -> list[ModelEndpoint]:
-        """Retrieves fallback endpoints for a role."""
-        return self._fallback_routes.get(role.lower(), [])
-
-    def instantiate_model(self, endpoint: ModelEndpoint) -> BaseChatModel:
-        """Instantiates a concrete LangChain chat model via the unified ModelFactory."""
-        return ModelFactory.create_model(endpoint)
-
-    def create_chat_model(self, role: str) -> BaseChatModel:
-        """Creates a chat model with configured fallbacks for the specified role."""
-        primary_endpoint = self.get_endpoint(role)
-        primary_model = self.instantiate_model(primary_endpoint)
-
-        fallbacks = self.get_fallbacks(role)
-        if fallbacks:
-            fallback_models = [self.instantiate_model(ep) for ep in fallbacks]
-            return primary_model.with_fallbacks(fallback_models)
-
-        return primary_model
-
-
-# Global singleton router instance
-default_router = ModelRouter()