clm-kernel 0.0.0__py3-none-any.whl

clm/layer3/agency/providers/ollama.py

@@ -0,0 +1,203 @@
+"""
+Ollama Provider Implementation
+
+Provider for the Ollama local LLM service.
+https://ollama.ai/
+"""
+
+import json
+import logging
+import urllib.error
+import urllib.request
+from typing import Any
+
+from clm.cross_cutting.config.config_constants import LLM_DEFAULT_TIMEOUT_SECS
+from clm.cross_cutting.utils.url_safety import safe_urlopen
+from clm.layer0.narrative import Either, Left, Right
+
+from ..config import LLM_PROVIDERS
+from .base import LLMProvider
+
+
+class OllamaProvider(LLMProvider):
+    """
+    Ollama LLM provider for local model execution.
+
+    Ollama provides a simple API for running LLMs locally:
+    - /api/generate - Text completion
+    - /api/chat - Chat completion
+    - /api/tags - List available models
+    """
+
+    provider_name = "ollama"
+
+    def __init__(self, base_url: str = None, timeout: int = LLM_DEFAULT_TIMEOUT_SECS):
+        self.logger = logging.getLogger(__name__)
+        self.config = LLM_PROVIDERS["ollama"]
+        self.base_url = (base_url or self.config["base_url"]).rstrip("/")
+        self.timeout = timeout
+
+    def _make_request(
+        self, endpoint: str, data: dict = None, method: str = "POST"
+    ) -> Either[str, dict]:
+        """Make HTTP request to Ollama API."""
+        url = f"{self.base_url}{endpoint}"
+
+        try:
+            if data:
+                request = urllib.request.Request(
+                    url,
+                    data=json.dumps(data).encode("utf-8"),
+                    headers={"Content-Type": "application/json"},
+                    method=method,
+                )
+            else:
+                request = urllib.request.Request(url, method=method)
+
+            with safe_urlopen(request, timeout=self.timeout) as response:
+                response_text = response.read().decode("utf-8")
+
+                # Handle streaming response (multiple JSON objects)
+                if "\n" in response_text and not response_text.strip().startswith("{"):
+                    # Parse last complete response for final result
+                    lines = [line for line in response_text.strip().split("\n") if line]
+                    if lines:
+                        return Right(json.loads(lines[-1]))
+
+                return Right(json.loads(response_text))
+
+        except urllib.error.HTTPError as e:
+            error_body = e.read().decode("utf-8") if e.fp else str(e)
+            return Left(f"Ollama HTTP error {e.code}: {error_body}")
+        except urllib.error.URLError as e:
+            return Left(f"Ollama connection error: {e.reason}")
+        except json.JSONDecodeError as e:
+            return Left(f"Ollama response parse error: {e}")
+        except (OSError, ConnectionError, ValueError) as e:
+            return Left(f"Ollama request failed: {e}")
+
+    def complete(self, prompt: str, params: dict[str, Any]) -> Either[str, str]:
+        """
+        Generate text completion using Ollama's /api/generate endpoint.
+
+        Args:
+            prompt: The input prompt
+            params: Generation parameters (model, options, etc.)
+
+        Returns:
+            Either[Error, Completion]
+        """
+        data = {
+            "model": params.get("model", self.config["default_model"]),
+            "prompt": prompt,
+            "stream": False,  # Disable streaming for simpler handling
+        }
+
+        # Add options if present
+        if "options" in params:
+            data["options"] = params["options"]
+
+        self.logger.debug(f"Ollama generate request: model={data['model']}")
+
+        result = self._make_request(self.config["api_path"], data)
+
+        if result.is_left():
+            return result
+
+        response = result.value
+        if "response" in response:
+            return Right(response["response"])
+        elif "error" in response:
+            return Left(f"Ollama error: {response['error']}")
+        else:
+            return Left(f"Unexpected Ollama response format: {response}")
+
+    def chat(
+        self, messages: list[dict[str, str]], params: dict[str, Any]
+    ) -> Either[str, dict[str, Any]]:
+        """
+        Generate chat completion using Ollama's /api/chat endpoint.
+
+        Args:
+            messages: List of message dicts with 'role' and 'content'
+            params: Generation parameters
+
+        Returns:
+            Either[Error, ResponseDict]
+        """
+        data = {
+            "model": params.get("model", self.config["default_model"]),
+            "messages": messages,
+            "stream": False,
+        }
+
+        # Add options if present
+        if "options" in params:
+            data["options"] = params["options"]
+
+        self.logger.debug(
+            f"Ollama chat request: model={data['model']}, messages={len(messages)}"
+        )
+
+        result = self._make_request(self.config["chat_path"], data)
+
+        if result.is_left():
+            return result
+
+        response = result.value
+        if "message" in response:
+            chat_result = {
+                "content": response["message"].get("content", ""),
+                "role": response["message"].get("role", "assistant"),
+                "model": response.get("model", data["model"]),
+                "done": response.get("done", True),
+                "done_reason": response.get("done_reason"),
+                "total_duration": response.get("total_duration"),
+                "eval_count": response.get("eval_count"),
+            }
+
+            # Surface thinking field from thinking models (e.g. qwen3:0.6b)
+            # Ollama returns thinking as a separate field in the message,
+            # distinct from the <think> blocks in content.
+            if "thinking" in response["message"]:
+                chat_result["thinking"] = response["message"]["thinking"]
+
+            return Right(chat_result)
+        elif "error" in response:
+            return Left(f"Ollama error: {response['error']}")
+        else:
+            return Left(f"Unexpected Ollama chat response format: {response}")
+
+    def validate_connection(self) -> bool:
+        """Check if Ollama service is running."""
+        try:
+            result = self._make_request(self.config["models_path"], method="GET")
+            return result.is_right()
+        except (OSError, ConnectionError):
+            return False
+
+    def list_models(self) -> Either[str, list[str]]:
+        """List available models in Ollama."""
+        result = self._make_request(self.config["models_path"], method="GET")
+
+        if result.is_left():
+            return result
+
+        response = result.value
+        if "models" in response:
+            models = [
+                m.get("name", m.get("model", "unknown")) for m in response["models"]
+            ]
+            return Right(models)
+        else:
+            return Left(f"Unexpected models response: {response}")
+
+    def pull_model(self, model_name: str) -> Either[str, str]:
+        """Pull a model from Ollama library."""
+        data = {"name": model_name, "stream": False}
+        result = self._make_request("/api/pull", data)
+
+        if result.is_left():
+            return result
+
+        return Right(f"Model {model_name} pulled successfully")

clm/layer3/agency/router.py

@@ -0,0 +1,71 @@
+import logging
+
+from clm.cross_cutting.config.config_constants import (
+    DEFAULT_FALLBACK_MODEL,
+    DEFAULT_OLLAMA_BASE_URL,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class IntelligenceRouter:
+    """
+    IntelligenceRouter handles Adaptive Intelligence Routing across LLM providers.
+
+    Complies with the 'Local-First Sovereign AI' mandate by connection probing
+    and automatically determining the most appropriate fallback when primary
+    cloud pipelines are incapacitated.
+    """
+
+    def __init__(self):
+        # By default we configure local ollama for failover
+        self.local_url = DEFAULT_OLLAMA_BASE_URL
+        self.local_model = DEFAULT_FALLBACK_MODEL
+
+    def probe_connection(self, provider_url: str, timeout: float = 2.0) -> bool:
+        """
+        Probe a remote provider URL recursively.
+        Returns True if reachable within the timeout.
+        """
+        import httpx
+
+        try:
+            # We use a lightweight GET over the base URL.
+            # While some APIs require deeper paths, an error 404 or 401 is still
+            # a network connection success, while a Timeout isn't.
+            httpx.get(provider_url, timeout=timeout)
+            return True
+        except httpx.RequestError as e:
+            logger.warning(
+                f"[IntelligenceRouter] Connection Probe Failed for {provider_url}: {str(e)}"
+            )
+            return False
+
+    def get_optimal_provider(
+        self,
+        requested_provider: str,
+        requested_model: str,
+        requested_url: str | None = None,
+    ) -> tuple[str, str, str | None]:
+        """
+        Returns the (provider, model, base_url) that is optimal.
+        For now, this simply favors the requested configuration unless
+        a failure explicitly overrides it.
+        """
+        return requested_provider, requested_model, requested_url
+
+    def handle_failure(
+        self, failed_provider: str, error: Exception
+    ) -> tuple[str, str, str | None, str]:
+        """
+        Returns the fallback configuration tuple and a warning message to store.
+        (fallback_provider, fallback_model, fallback_url, warning_message)
+        """
+        msg = (
+            f"Adaptive Fallback Triggered: Provider '{failed_provider}' "
+            f"failed with {type(error).__name__}. Defaulting to Edge Fallback "
+            f"[{self.local_model}] via Ollama."
+        )
+        logger.warning(f"[IntelligenceRouter] {msg}")
+
+        return "ollama", self.local_model, self.local_url, msg