Phase 5 architecture consolidation

PHASE_5_ARCHITECTURE_CONSOLIDATION.md

@@ -0,0 +1,47 @@
+# Phase 5 — Architecture Consolidation
+
+## Status
+
+**Implementation complete on `phase-5-architecture-consolidation`; final full-suite/CI verification is environment-dependent.**
+
+## Target architecture
+
+```text
+User Request
+    ↓
+Task Classifier
+    ↓
+Task Complexity
+    ↓
+Model Policy
+    ↓
+ModelRouter
+    ↓
+Structured RoutingDecision
+    ↓
+LLMFactory
+    ↓
+Ollama
+    ↓
+Response / AgentResult
+```
+
+## What changed
+
+- Added authoritative `TaskType`, `TaskComplexity`, `AgentRequest`, `AgentResult`, `ModelPolicy`, `RoutingDecision`, and `ModelRouter`.
+- Made `LLMFactory` consume structured routing decisions and remain the provider-instantiation boundary.
+- Moved the existing deterministic model-selection rules out of `ollama_service.py` into `ModelPolicy`.
+- Routed FastAPI generation/fix flows through `ModelRouter` and `LLMFactory`.
+- Converted `OllamaProvider` to the shared `BaseLLMProvider` contract.
+- Retired the simulated `ModelOrchestrator` and duplicate `ProviderManager`.
+- Kept low-level Ollama compatibility helpers without allowing them to perform business-level model routing.
+- Added dedicated Phase 5 routing regression tests.
+- Updated architecture documentation and the ecosystem check.
+
+## Verification boundary
+
+Core Phase 5 routing behavior was AST-validated and exercised in isolation, including deterministic model selection, task classification, complexity classification, structured routing decisions, and unsupported-provider rejection.
+
+The repository's existing CI workflow does not execute on this Phase 5 branch for push events, and the GitHub connector available for this execution cannot run arbitrary local `pytest`, Flake8, or `pip check` commands. No live Ollama result is claimed.
+
+The branch remains unmerged and independent from `main`.

backend/app/llm/factory.py

@@ -9,12 +9,13 @@
 from .providers.fallback import FallbackProvider
 from .providers.ollama import OllamaProvider
 from .providers.openai import OpenAIProvider
+from .routing import RoutingDecision
 
 logger = logging.getLogger("codemaster-ai")
 
 
 class LLMFactory:
-    """Factory and registry for provider instantiation."""
+    """Single authoritative provider-instantiation boundary."""
 
     _registry: Dict[str, Type[BaseLLMProvider]] = {
         "ollama": OllamaProvider,
@@ -24,16 +25,29 @@ class LLMFactory:
 
     @classmethod
     def create_provider(cls, provider_name: str | None = None) -> BaseLLMProvider:
-        provider_key = (provider_name or os.getenv("LLM_PROVIDER") or getattr(settings, "LLM_PROVIDER", "fallback") or "fallback").strip().lower()
+        """Create a provider; production routing normally supplies the name."""
+        provider_key = (
+            provider_name
+            or os.getenv("LLM_PROVIDER")
+            or getattr(settings, "LLM_PROVIDER", "fallback")
+            or "fallback"
+        ).strip().lower()
         provider_cls = cls._registry.get(provider_key)
         if provider_cls is None:
             logger.warning("Unknown provider '%s'; using fallback provider", provider_key)
-            return FallbackProvider("fallback")
+            provider_key = "fallback"
+            provider_cls = FallbackProvider
 
         provider = provider_cls(provider_key)
-        logger.info("LLMFactory selected provider '%s'", provider_key)
+        logger.info("LLMFactory created provider '%s'", provider_key)
         return provider
 
+    @classmethod
+    def create(cls, decision: RoutingDecision) -> tuple[BaseLLMProvider, str]:
+        """Create the provider selected by one structured routing decision."""
+        provider = cls.create_provider(decision.provider)
+        return provider, decision.model
+
     @classmethod
     def register_provider(cls, name: str, provider_cls: Type[BaseLLMProvider]) -> None:
         cls._registry[name.strip().lower()] = provider_cls

backend/app/llm/providers/ollama.py

@@ -1,49 +1,61 @@
-import httpx
-import logging
-import os
-
-logger = logging.getLogger("codemaster-ai")
-
-class OllamaProvider:
-
-
-    provider_name = "ollama"
-    def get_status(self) -> dict:
-        """Return the operational status of the Ollama provider."""
-        return {
-            "provider": "ollama",
-            "status": "healthy" if (self.is_available() if callable(getattr(self, "is_available", None)) else getattr(self, "is_available", True)) else "degraded"
-        }
-    def __init__(self, provider_key: str = "ollama"):
-        self.base_url = os.getenv("OLLAMA_BASE_URL", "http://localhost:11434")
-        self.is_available = os.getenv("OLLAMA_ENABLED", "true").lower() == "true"
-        self._last_error = None
-
-    async def generate(self, prompt: str, **kwargs) -> str:
-        if not self.is_available:
-            raise RuntimeError("ollama provider is disabled")
-
-        model = kwargs.get("model", "qwen2.5-coder:1.5b")
-        url = f"{self.base_url}/api/generate"
-        payload = {
-            "model": model,
-            "prompt": prompt,
-            "stream": False
-        }
-        try:
-            async with httpx.AsyncClient(timeout=60.0) as client:
-                response = await client.post(url, json=payload)
-                if response.status_code != 200:
-                    raise RuntimeError(f"Ollama API error: {response.text}")
-                data = response.json()
-                return data.get("response", "")
-        except Exception as e:
-            logger.error(f"Ollama generation failed: {e}")
-            raise RuntimeError(f"Ollama generation failed: {e}")
-
-    def is_ready(self) -> bool:
-        import os
-        val = os.getenv("OLLAMA_ENABLED")
-        if val is not None:
-            return val.lower() not in ("false", "0", "no", "off")
-        return True
+from __future__ import annotations
+
+import logging
+import os
+from typing import Any, Dict
+
+import httpx
+
+from .base import BaseLLMProvider
+
+logger = logging.getLogger("codemaster-ai")
+
+
+class OllamaProvider(BaseLLMProvider):
+    """Local Ollama provider implementation.
+
+    Model selection is supplied by ModelRouter/LLMFactory. The provider only
+    executes the already-selected provider/model request.
+    """
+
+    def __init__(self, provider_name: str | None = None):
+        super().__init__(provider_name or "ollama")
+        self.base_url = os.getenv("OLLAMA_BASE_URL", "http://localhost:11434")
+        self.enabled = os.getenv("OLLAMA_ENABLED", "true").lower() == "true"
+        self._last_error: str | None = None
+
+    async def generate(self, prompt: str, model: str | None = None) -> str:
+        if not self.is_ready():
+            raise RuntimeError("ollama provider is disabled")
+
+        selected_model = model or "qwen2.5-coder:1.5b"
+        url = f"{self.base_url.rstrip('/')}/api/generate"
+        payload = {"model": selected_model, "prompt": prompt, "stream": False}
+        try:
+            async with httpx.AsyncClient(timeout=60.0) as client:
+                response = await client.post(url, json=payload)
+                if response.status_code != 200:
+                    raise RuntimeError(f"Ollama API error: {response.text}")
+                data = response.json()
+                result = data.get("response", "")
+                if not isinstance(result, str):
+                    raise RuntimeError("Ollama returned a malformed response")
+                self._last_error = None
+                return result
+        except Exception as exc:
+            self._last_error = str(exc)
+            logger.error("Ollama generation failed: %s", exc)
+            raise RuntimeError(f"Ollama generation failed: {exc}") from exc
+
+    def is_ready(self) -> bool:
+        value = os.getenv("OLLAMA_ENABLED")
+        if value is not None:
+            return value.lower() not in ("false", "0", "no", "off")
+        return self.enabled
+
+    def get_status(self) -> Dict[str, Any]:
+        return {
+            "provider": self.provider_name,
+            "ready": self.is_ready(),
+            "last_error": self._last_error,
+        }