cct-cli 0.7.9.0__py3-none-any.whl

calc_terminal/providers/discovery_manager.py

@@ -0,0 +1,207 @@
+"""
+calc_terminal/providers/discovery_manager.py
+===========================================
+Provider Discovery Manager for Dynamic Model and Provider Discovery.
+
+Coordinates adapter-driven live discovery across all supported providers,
+reconciles results against DynamicModelRegistry, and notifies users when
+new models are detected.
+
+Features:
+  - Non-blocking asynchronous discovery loops.
+  - Fail-safe timeout bounding and graceful error recovery.
+  - Offline mode detection and stale cache preservation.
+  - Live health status tracking (ONLINE, DEGRADED, OFFLINE, UNKNOWN).
+"""
+
+import concurrent.futures
+import json
+import logging
+import os
+import threading
+import time
+from typing import Dict, List, Optional, Any, Callable
+
+from .adapters import get_adapter, list_supported_adapters
+from ..models.dynamic_registry import get_registry, DynamicModelRegistry
+from ..models.schema import ModelInfo
+
+_LOG = logging.getLogger("cct.discovery_manager")
+
+
+class ProviderDiscoveryManager:
+    """Manages continuous background model discovery and reconciliation."""
+
+    _instance: Optional["ProviderDiscoveryManager"] = None
+    _lock = threading.Lock()
+
+    def __new__(cls, *args, **kwargs):
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super(ProviderDiscoveryManager, cls).__new__(cls)
+                cls._instance._initialized = False
+            return cls._instance
+
+    def __init__(self, registry: Optional[DynamicModelRegistry] = None):
+        if getattr(self, "_initialized", False):
+            return
+        self.registry = registry or get_registry()
+        self._provider_status: Dict[str, Dict[str, Any]] = {}
+        self._notification_hooks: List[Callable[[List[ModelInfo]], None]] = []
+        self._bg_thread: Optional[threading.Thread] = None
+        self._stop_event = threading.Event()
+        self._initialized = True
+
+    # ── Notification Hooks ─────────────────────────────────────────────────────
+
+    def add_notification_hook(self, hook: Callable[[List[ModelInfo]], None]):
+        """Register a callback for when new models are detected."""
+        if hook not in self._notification_hooks:
+            self._notification_hooks.append(hook)
+
+    register_notification_hook = add_notification_hook
+
+    def _notify_new_models(self, new_models: List[ModelInfo]):
+        for hook in self._notification_hooks:
+            try:
+                hook(new_models)
+            except Exception as e:
+                _LOG.warning(f"Error executing discovery notification hook: {e}")
+
+    # ── Single Provider Discovery ──────────────────────────────────────────────
+
+    def discover_provider(
+        self,
+        provider_id: str,
+        config: Optional[Dict[str, Any]] = None,
+        timeout: float = 6.0,
+    ) -> List[ModelInfo]:
+        """Run discovery for a single provider and reconcile with registry."""
+        pid = provider_id.lower().strip()
+        adapter = get_adapter(pid, config)
+
+        try:
+            discovered = adapter.discover_models(timeout=timeout)
+            if discovered:
+                diff = self.registry.reconcile_models(pid, discovered)
+                self._provider_status[pid] = {
+                    "status": "online",
+                    "models_count": len(discovered),
+                    "last_checked": time.time(),
+                    "diff": diff,
+                }
+                # Check for newly discovered models
+                new_models = self.registry.pop_new_models()
+                if new_models:
+                    self._notify_new_models(new_models)
+                return discovered
+            else:
+                self._provider_status[pid] = {
+                    "status": "degraded",
+                    "models_count": 0,
+                    "last_checked": time.time(),
+                    "message": "Zero models returned",
+                }
+        except Exception as e:
+            _LOG.warning(f"Discovery failed for {pid}: {e}")
+            self._provider_status[pid] = {
+                "status": "offline",
+                "last_checked": time.time(),
+                "error": str(e),
+            }
+
+        # Fallback to previously cached registry models
+        return self.registry.list_models(provider=pid)
+
+    # ── Parallel Discovery Across All Providers ────────────────────────────────
+
+    def discover_all(
+        self,
+        provider_configs: Optional[Dict[str, Dict[str, Any]]] = None,
+        timeout_per_provider: float = 6.0,
+        max_workers: int = 8,
+    ) -> Dict[str, List[ModelInfo]]:
+        """Discover models across all supported providers in parallel."""
+        supported = list_supported_adapters()
+        configs = provider_configs or {}
+        results: Dict[str, List[ModelInfo]] = {}
+
+        # Prioritize key providers first
+        priority_pids = [
+            "openai", "anthropic", "gemini", "deepseek", "alibaba",
+            "moonshot", "zhipu", "ollama", "xai", "mistral", "minimax"
+        ]
+        all_pids = list(priority_pids) + [p for p in supported.keys() if p not in priority_pids]
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+            future_to_pid = {
+                executor.submit(
+                    self.discover_provider, pid, configs.get(pid), timeout_per_provider
+                ): pid
+                for pid in all_pids
+            }
+            for future in concurrent.futures.as_completed(future_to_pid):
+                pid = future_to_pid[future]
+                try:
+                    results[pid] = future.result()
+                except Exception as e:
+                    results[pid] = []
+                    _LOG.warning(f"Exception during discovery for {pid}: {e}")
+
+        return results
+
+    # ── Background Worker ──────────────────────────────────────────────────────
+
+    def start_background_discovery(self, interval_hours: float = 24.0, delay_startup: float = 1.0):
+        """Launch background discovery thread."""
+        if self._bg_thread and self._bg_thread.is_alive():
+            return
+
+        self._stop_event.clear()
+
+        def _loop():
+            # Initial brief delay so CAT startup finishes instantly
+            self._stop_event.wait(delay_startup)
+            if self._stop_event.is_set():
+                return
+            try:
+                self.discover_all()
+            except Exception as e:
+                _LOG.warning(f"Background initial discovery error: {e}")
+
+            # Periodic loop
+            while not self._stop_event.is_set():
+                self._stop_event.wait(interval_hours * 3600.0)
+                if self._stop_event.is_set():
+                    break
+                try:
+                    self.discover_all()
+                except Exception as e:
+                    _LOG.warning(f"Background periodic discovery error: {e}")
+
+        self._bg_thread = threading.Thread(
+            target=_loop,
+            daemon=True,
+            name="cct-discovery-manager",
+        )
+        self._bg_thread.start()
+
+    def stop_background_discovery(self):
+        """Stop background discovery thread."""
+        self._stop_event.set()
+
+    # ── Status Inspection ──────────────────────────────────────────────────────
+
+    def get_provider_status(self, provider_id: str) -> Dict[str, Any]:
+        pid = provider_id.lower().strip()
+        return self._provider_status.get(pid, {"status": "unknown", "provider": pid})
+
+    def get_all_provider_statuses(self) -> Dict[str, Dict[str, Any]]:
+        return dict(self._provider_status)
+
+    get_all_provider_status = get_all_provider_statuses
+
+
+# Singleton convenience accessor
+def get_discovery_manager() -> ProviderDiscoveryManager:
+    return ProviderDiscoveryManager()

calc_terminal/providers/gemini_provider.py

@@ -0,0 +1,178 @@
+"""Google Gemini provider."""
+
+import json
+import time
+from typing import Optional
+
+import requests
+
+from .base_provider import BaseProvider
+
+
+class GeminiProvider(BaseProvider):
+    ID = "gemini"
+    NAME = "Google Gemini"
+    NEEDS_KEY = True
+    DEFAULT_MODEL = "gemini-1.5-flash-latest"  # fallback only — resolved from providers.json when available
+    API_STYLE = "gemini"
+    supports_tools = True
+    supports_reasoning = True
+    supports_vision = True
+    supports_streaming = True
+    supports_audio = True
+    supports_embeddings = True
+
+    @classmethod
+    def _default_url(cls):
+        return "https://generativelanguage.googleapis.com/v1beta"
+
+    @classmethod
+    def default_model(cls):
+        """Data-driven default from providers.json; DEFAULT_MODEL as fallback."""
+        from ..models import manager as _mgr
+        return _mgr.default_model_for(cls.ID, cls.DEFAULT_MODEL)
+
+    def _key_suffix(self):
+        return f"?key={self.get_api_key()}"
+
+    def _build_contents(self, history, prompt):
+        contents = []
+        for role, text in (history or []):
+            r = "model" if role == "assistant" else "user"
+            contents.append({"role": r, "parts": [{"text": text}]})
+        contents.append({"role": "user", "parts": [{"text": prompt}]})
+        return contents
+
+    def fetch_models(self) -> list[str]:
+        base = self.get_base_url()
+        key = self.get_api_key()
+        if not base or not key:
+            return []
+        try:
+            resp = requests.get(f"{base}/models{self._key_suffix()}", timeout=10)
+            if resp.status_code >= 400:
+                return []
+            out = []
+            for m in resp.json().get("models", []):
+                methods = m.get("supportedGenerationMethods", [])
+                if not methods or "generateContent" in methods:
+                    out.append(m.get("name", "").split("/")[-1])
+            return sorted(set(n for n in out if n))
+        except Exception:
+            return []
+
+    def connect(self) -> tuple[bool, str, list[str]]:
+        models = self.fetch_models()
+        if models:
+            return True, f"Connected \u2014 {len(models)} model(s) visible", models
+        return False, "Could not connect \u2014 check API key", []
+
+    def chat(self, prompt, system_prompt="", history=None) -> str:
+        base = self.get_base_url()
+        if not base:
+            return "AI not configured."
+        model = self.get_model()
+        try:
+            url = f"{base}/models/{model}:generateContent{self._key_suffix()}"
+            payload = {
+                "contents": self._build_contents(history, prompt),
+                "systemInstruction": {"parts": [{"text": system_prompt or ""}]},
+            }
+            temp = self.config.get("temperature")
+            top_p = self.config.get("top_p")
+            if temp is not None or top_p is not None:
+                gen = {}
+                if temp is not None:
+                    gen["temperature"] = temp
+                if top_p is not None:
+                    gen["topP"] = top_p
+                payload["generationConfig"] = gen
+            resp = requests.post(url, json=payload, timeout=30)
+            self._raise_for_status(resp)
+            data = resp.json()
+            return data["candidates"][0]["content"]["parts"][0]["text"]
+        except Exception as e:
+            return f"Error: {e}"
+
+    def stream(self, prompt, system_prompt="", history=None):
+        base = self.get_base_url()
+        if not base:
+            yield "AI not configured."
+            return
+        model = self.get_model()
+        try:
+            url = (f"{base}/models/{model}:streamGenerateContent"
+                   f"?alt=sse{self._key_suffix()}")
+            payload = {
+                "contents": self._build_contents(history, prompt),
+                "systemInstruction": {"parts": [{"text": system_prompt or ""}]},
+            }
+            temp = self.config.get("temperature")
+            top_p = self.config.get("top_p")
+            if temp is not None or top_p is not None:
+                gen = {}
+                if temp is not None:
+                    gen["temperature"] = temp
+                if top_p is not None:
+                    gen["topP"] = top_p
+                payload["generationConfig"] = gen
+            resp = requests.post(url, json=payload, timeout=60, stream=True)
+            self._raise_for_status(resp)
+            for line in resp.iter_lines(decode_unicode=True):
+                if not line or not line.startswith("data:"):
+                    continue
+                try:
+                    obj = json.loads(line[5:].strip())
+                except ValueError:
+                    continue
+                candidates = obj.get("candidates") or []
+                if candidates:
+                    parts = (candidates[0].get("content") or {}).get("parts") or []
+                    for part in parts:
+                        piece = part.get("text")
+                        if piece:
+                            yield piece
+        except Exception as e:
+            yield f"Error: {e}"
+
+    def vision(self, prompt, image_b64, mime) -> str:
+        base = self.get_base_url()
+        if not base:
+            return "AI not configured."
+        model = self.get_model()
+        try:
+            url = f"{base}/models/{model}:generateContent{self._key_suffix()}"
+            payload = {
+                "contents": [{"role": "user", "parts": [
+                    {"text": prompt},
+                    {"inline_data": {"mime_type": mime, "data": image_b64}},
+                ]}],
+            }
+            resp = requests.post(url, json=payload, timeout=60)
+            self._raise_for_status(resp)
+            return resp.json()["candidates"][0]["content"]["parts"][0]["text"]
+        except Exception as e:
+            return f"Vision error: {e}"
+
+    def health_check(self) -> dict:
+        start = time.time()
+        models = self.fetch_models()
+        elapsed = time.time() - start
+        return {
+            "provider": self.ID,
+            "status": "ok" if models else "error",
+            "latency_ms": round(elapsed * 1000),
+            "models_count": len(models),
+            "base_url": self.get_base_url(),
+        }
+
+    @staticmethod
+    def _raise_for_status(resp):
+        if resp.status_code >= 400:
+            try:
+                body = resp.json()
+                err = (body.get("error", {}).get("message")
+                       or str(body)[:300])
+            except Exception:
+                err = resp.text[:300] if resp.text else resp.reason
+            raise RuntimeError(f"HTTP {resp.status_code}: {err}")