free-fleet 0.2.4__py3-none-any.whl

free_fleet/__init__.py

@@ -0,0 +1,116 @@
+"""Free Fleet: Coordinated free & local LLM worker fleet with closed fields and exact source evidence."""
+__version__ = "0.2.4"
+import json
+from pathlib import Path
+from .task import load_task_spec
+from .engine import Engine
+from .catalog import RouteCatalog
+from .grounding import verify_grounding
+from .models import CleanPacket, ExtractedItem, InputItem, ModelOutput, QuoteRef, TaskSpec
+from .input_data import load_input_items
+from .store import BulkLanesStore, FreeFleetStore
+from .slicer import slice_document
+from .packer import pack_items
+from .export import export_clean_packet
+
+def read_packet(packet_path: str) -> dict:
+    """Convenience helper for downstream trusted applications to safely load a clean packet."""
+    p = Path(packet_path).resolve()
+    if not p.exists():
+        raise FileNotFoundError(f"Packet file not found: {packet_path}")
+    return CleanPacket.model_validate_json(p.read_text()).model_dump(mode="json", by_alias=True)
+
+def process(
+    task: str | TaskSpec | Path,
+    input: str | Path | list[InputItem] | list[dict],
+    run_id: str | None = None,
+    concurrency: int = 4,
+    max_attempts: int = 300,
+    output: str | Path | None = None,
+    policy=None,
+    db: str | Path | None = None,
+    **load_kwargs,
+) -> dict:
+    """High-level Python SDK: `free_fleet.process(task, input, ...) -> packet`.
+
+    Example:
+        import free_fleet
+        packet = free_fleet.process("my-task", "data.csv", concurrency=8)
+        df = packet["records"]  # or use export helpers
+
+    Supports local paths (.csv/.jsonl/.json/.txt/.html/.pdf), lists of InputItem,
+    or pandas DataFrames (if installed) via `input=df`.
+    """
+    import time as _time
+
+    # Resolve task
+    from pathlib import Path as _P
+
+    store = FreeFleetStore(_P(db)) if db is not None else FreeFleetStore()
+    if isinstance(task, TaskSpec):
+        spec = task
+        store.register_task(spec)
+    elif isinstance(task, (str, _P)) and _P(str(task)).is_file():
+        spec = load_task_spec(str(task))
+        store.register_task(spec)
+    else:
+        spec = store.get_task(str(task))
+
+    # Resolve input items (DataFrame support optional)
+    items: list[InputItem]
+    input_path_str = str(input) if isinstance(input, (str, _P)) else "python-sdk"
+    if isinstance(input, list):
+        # Already InputItem/dict list
+        items = [i if isinstance(i, InputItem) else InputItem.model_validate(i) for i in input]  # type: ignore
+    elif isinstance(input, (str, _P)) and _P(str(input)).is_file():
+        items = load_input_items(str(input), **load_kwargs)  # type: ignore
+    else:
+        # Try DataFrame-like (has to_dict)
+        try:
+            if hasattr(input, "to_dict") and hasattr(input, "columns"):
+                # pandas DataFrame
+                recs = input.to_dict(orient="records")  # type: ignore
+                # Heuristic columns: try to detect id/text columns
+                items = []
+                for idx, rec in enumerate(recs):
+                    # Prefer explicit id column
+                    cand_id = rec.get("item_id") or rec.get("id") or f"row_{idx}"
+                    txt = rec.get("text") or rec.get("body") or rec.get("content") or rec.get("description") or ""
+                    if not txt:
+                        # fallback: first stringifiable column value
+                        for v in rec.values():
+                            if isinstance(v, str) and len(v.strip()) > 20:
+                                txt = v
+                                break
+                    items.append(InputItem(item_id=str(cand_id), text=str(txt), metadata={k: v for k, v in rec.items() if k not in ("item_id", "id", "text", "body", "content")}))
+            else:
+                raise TypeError("unsupported input type")
+        except Exception as e:
+            raise ValueError(f"Unable to resolve input '{input}': {e}") from e
+
+    rid = run_id or f"sdk-{int(_time.time())}"
+    out_path = _P(output) if output is not None else _P(f"runs/{rid}/clean_packet.json")
+    eng = Engine(task=spec, store=store, policy=policy)
+    return eng.run_campaign(raw_items=items, run_id=rid, input_path=input_path_str, concurrency=concurrency, max_attempts=max_attempts, output_packet_path=out_path)
+
+__all__ = [
+    "load_task_spec",
+    "Engine",
+    "RouteCatalog",
+    "verify_grounding",
+    "CleanPacket",
+    "ExtractedItem",
+    "InputItem",
+    "ModelOutput",
+    "QuoteRef",
+    "TaskSpec",
+    "FreeFleetStore",
+    "BulkLanesStore",
+    "load_input_items",
+    "slice_document",
+    "pack_items",
+    "export_clean_packet",
+    "read_packet",
+    "process",
+    "__version__",
+]

free_fleet/catalog.py

@@ -0,0 +1,520 @@
+"""Route catalog and dynamic circuit-breaker management with automated free-schema discovery."""
+import hashlib
+import json
+import re
+import shutil
+import subprocess
+import threading
+import time
+from enum import Enum
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+import httpx
+
+from .models import RouteInfo
+from .store import BulkLanesStore
+
+DEFAULT_CONFIG_PATH = Path(__file__).resolve().parent / "data" / "routes.seed.json"
+
+class RouteCircuitBreaker(Exception):
+    pass
+
+class PriceState(str, Enum):
+    CANDIDATE = "candidate"
+    PRICE_OBSERVED_ZERO = "price_observed_zero"
+    UNKNOWN = "unknown"
+    DISABLED = "disabled"
+
+
+def _observed_prices(model_data: dict) -> list[float] | None:
+    pricing = model_data.get("pricing") or model_data.get("cost")
+    if isinstance(pricing, dict):
+        input_value = pricing.get("prompt", pricing.get("input"))
+        output_value = pricing.get("completion", pricing.get("output"))
+        if input_value is None or output_value is None:
+            return None
+        raw_values: list[Any] = []
+
+        def collect(value: Any) -> None:
+            if isinstance(value, dict):
+                for nested in value.values():
+                    collect(nested)
+            elif value is not None:
+                raw_values.append(value)
+
+        collect(pricing)
+        try:
+            return [float(value) for value in raw_values]
+        except (TypeError, ValueError):
+            return None
+    return None
+
+
+def classify_price_state(model_data: dict) -> PriceState:
+    """Classify evidence without treating marketing text as observed pricing."""
+    prices = _observed_prices(model_data)
+    if prices is not None:
+        return PriceState.PRICE_OBSERVED_ZERO if all(value == 0 for value in prices) else PriceState.UNKNOWN
+    schema_dump = json.dumps(model_data).lower()
+    if re.search(r"(\bfree\b|:free|-free|_free)", schema_dump):
+        return PriceState.CANDIDATE
+    return PriceState.UNKNOWN
+
+
+def is_free_in_schema(model_data: dict) -> bool:
+    """Compatibility predicate: true only for explicit observed zero pricing."""
+    return classify_price_state(model_data) is PriceState.PRICE_OBSERVED_ZERO
+
+class RouteCatalog:
+    def __init__(self, config_path: Optional[Path] = None, db_path: Optional[Path] = None):
+        self.config_path = config_path or DEFAULT_CONFIG_PATH
+        self._lock = threading.RLock()
+        resolved_db = db_path or (self.config_path.with_suffix(".db") if config_path else None)
+        self.store = BulkLanesStore(resolved_db)
+        if self.store.route_count() == 0:
+            self._seed_from_json()
+        self.data = self._load()
+
+    def _seed_from_json(self) -> None:
+        """Import packaged route hints without treating bundled history as local evidence."""
+        if not self.config_path.exists():
+            return
+        data = json.loads(self.config_path.read_text())
+        for raw_route in data.get("routes", []):
+            route = dict(raw_route)
+            hinted_zero = (
+                route.get("price_state") == PriceState.PRICE_OBSERVED_ZERO.value
+                or (route.get("cost_per_1k_input") == 0 and route.get("cost_per_1k_output") == 0)
+            )
+            route["enabled"] = False
+            route["price_state"] = PriceState.CANDIDATE.value if hinted_zero else PriceState.UNKNOWN.value
+            route["last_verified"] = None
+            route["verification_source"] = "packaged route hint; refresh required"
+            route.pop("zero_price_verified", None)
+            self.store.upsert_route(RouteInfo.model_validate(route))
+
+    def _load(self) -> dict:
+        routes = self.store.list_routes(observed_zero_only=False, include_disabled=True)
+        return {"revision": 2, "routes": [route.model_dump(mode="json") for route in routes]}
+
+    def save(self):
+        with self._lock:
+            for raw_route in self.data.get("routes", []):
+                self.store.upsert_route(RouteInfo.model_validate(raw_route))
+
+    def get_routes(
+        self,
+        provider: Optional[str] = None,
+        free_only: bool = True,
+        include_disabled: bool = False,
+    ) -> List[dict]:
+        routes = self.data.get("routes", [])
+        matched = []
+        for r in routes:
+            if not include_disabled and not r.get("enabled", False):
+                continue
+            if provider and r.get("provider") != provider:
+                continue
+            if free_only and r.get("price_state") != PriceState.PRICE_OBSERVED_ZERO.value:
+                continue
+            matched.append(r)
+        return matched
+
+    def add_route(
+        self,
+        route_id: str,
+        provider: str,
+        cost_per_1k_input: Optional[float] = None,
+        cost_per_1k_output: Optional[float] = None,
+        enabled: bool = True,
+        price_state: Optional[str] = None,
+        verification_source: str = "manual_registration",
+    ) -> RouteInfo:
+        """Register or update a route in the catalog."""
+        if price_state is None:
+            if (
+                cost_per_1k_input == 0
+                and cost_per_1k_output == 0
+                and cost_per_1k_input is not None
+                and cost_per_1k_output is not None
+            ):
+                price_state = PriceState.PRICE_OBSERVED_ZERO.value
+            else:
+                price_state = PriceState.UNKNOWN.value
+        route = RouteInfo(
+            id=route_id,
+            provider=provider,
+            enabled=enabled,
+            price_state=price_state,
+            cost_per_1k_input=cost_per_1k_input,
+            cost_per_1k_output=cost_per_1k_output,
+            last_verified=time.strftime("%Y-%m-%d"),
+            verification_source=verification_source,
+        )
+        self.store.upsert_route(route)
+        self.data = self._load()
+        return route
+
+    def set_cooldown(self, route_id: str, duration_sec: Optional[float] = None, reason: str = "") -> float:
+        """Temporarily cool down a route after rate limits or transient errors.
+        
+        If duration_sec is None, applies adaptive exponential backoff based on consecutive rate limits.
+        Returns the cooldown expiry timestamp.
+        """
+        if duration_sec is None:
+            return self.store.record_rate_limit_with_adaptive_backoff(route_id, reason)
+        expiry = time.time() + duration_sec
+        self.store.set_cooldown(route_id, expiry, reason)
+        return expiry
+
+    def is_cooled_down(self, route_id: str) -> bool:
+        """Check whether a route is currently in cooldown."""
+        return self.store.is_route_cooled_down(route_id)
+
+    def get_earliest_cooldown_retry(self, route_ids: Optional[List[str]] = None) -> float:
+        """Return the number of seconds until the earliest cooled-down route is available again."""
+        exp = self.store.get_earliest_cooldown_expiry(route_ids)
+        if exp:
+            return max(0.0, exp - time.time())
+        return 0.0
+
+    def get_route_summary(self, include_disabled: bool = True) -> list[dict[str, Any]]:
+        """Return comprehensive route catalog summary with Bayesian scores and attempt stats."""
+        routes = self.get_routes(free_only=False, include_disabled=include_disabled)
+        active_cooldowns = self.store.get_active_cooldowns()
+        now = time.time()
+
+        from .scoring import RouteScorer
+        scorer = RouteScorer(self.store)
+        history_stats = self.store.get_route_history_stats()
+        route_dicts = [r.model_dump(mode="json") if hasattr(r, "model_dump") else r for r in routes]
+        scores = scorer.score_routes(route_dicts)
+
+        summary = []
+        for r in routes:
+            rid = r["id"] if isinstance(r, dict) else r.id
+            provider = r["provider"] if isinstance(r, dict) else r.provider
+            enabled = r["enabled"] if isinstance(r, dict) else r.enabled
+            last_verified = r.get("last_verified") if isinstance(r, dict) else getattr(r, "last_verified", None)
+            stat = history_stats.get(rid, {})
+            cd_until = active_cooldowns.get(rid)
+            is_cooling = cd_until is not None and cd_until > now
+
+            status_str = "COOLING" if is_cooling else ("ACTIVE" if enabled else "DISABLED")
+            total = stat.get("total", 0)
+            completed = stat.get("completed", 0)
+            success_rate = (completed / total * 100.0) if total > 0 else None
+
+            summary.append({
+                "id": rid,
+                "provider": provider,
+                "enabled": enabled,
+                "status": status_str,
+                "is_cooling": is_cooling,
+                "cooling_seconds": round(max(0.0, cd_until - now), 1) if is_cooling else 0.0,
+                "bayesian_score": scores.get(rid, 0.5) if enabled and not is_cooling else (0.0 if is_cooling else 0.5),
+                "total_attempts": total,
+                "completed": completed,
+                "success_rate": success_rate,
+                "rate_limits": stat.get("rate_limits", 0),
+                "avg_duration": stat.get("avg_duration", 0.0),
+                "cooldown_until": cd_until,
+                "cooldown_remaining_sec": round(max(0.0, cd_until - now), 1) if is_cooling else 0.0,
+                "last_verified": last_verified,
+            })
+
+        def sort_key(x):
+            status_order = {"ACTIVE": 0, "COOLING": 1, "DISABLED": 2}.get(x["status"], 3)
+            return (status_order, -x["bayesian_score"])
+
+        return sorted(summary, key=sort_key)
+
+    def refresh_from_openai_compatible(
+        self,
+        base_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+        provider_name: str = "openai_compatible",
+    ) -> int:
+        """Discover routes from an OpenAI-compatible /models endpoint (e.g. Ollama, LM Studio, vLLM)."""
+        from .providers.openai_compatible import OpenAICompatibleProvider
+        provider = OpenAICompatibleProvider(base_url=base_url, api_key=api_key, provider_name=provider_name)
+        headers = {}
+        if provider.api_key:
+            headers["Authorization"] = f"Bearer {provider.api_key}"
+        try:
+            with httpx.Client(timeout=10.0) as client:
+                resp = client.get(f"{provider.base_url}/models", headers=headers)
+                if resp.status_code != 200:
+                    return 0
+                data = resp.json()
+                models = data.get("data", [])
+                count = 0
+                is_local = provider.is_local
+                price_state = PriceState.PRICE_OBSERVED_ZERO.value if is_local else PriceState.UNKNOWN.value
+                cost = 0.0 if is_local else None
+                for m in models:
+                    mid = m.get("id")
+                    if not mid:
+                        continue
+                    rid = f"{provider_name}/{mid}"
+                    self.add_route(
+                        route_id=rid,
+                        provider=provider_name,
+                        cost_per_1k_input=cost,
+                        cost_per_1k_output=cost,
+                        enabled=True,
+                        price_state=price_state,
+                        verification_source=f"{provider_name} /models discovery (local={is_local})",
+                    )
+                    count += 1
+                return count
+        except Exception:
+            return 0
+
+    def get_ladder(
+        self,
+        task_seed: str = "",
+        provider: Optional[str] = None,
+        free_only: bool = True,
+        task_name: Optional[str] = None,
+        policy: Optional[Any] = None,
+    ) -> List[str]:
+        """Returns an intelligently prioritized list of route IDs based on historical performance and eval scores."""
+        effective_free_only = free_only
+        if policy is not None:
+            # Explicit --free-only overrides; otherwise paid-aware policy disables free-only filter
+            if getattr(policy, "free_only", False):
+                effective_free_only = True
+            elif (
+                getattr(policy, "max_cost_per_1k_input", 0.0) > 0
+                or getattr(policy, "max_cost_per_1k_output", 0.0) > 0
+                or getattr(policy, "allowed_routes", None)
+            ):
+                effective_free_only = False
+        routes = self.get_routes(provider=provider, free_only=effective_free_only)
+        # Demo output is synthetic and must never enter a real campaign implicitly.
+        routes = [r for r in routes if r.get("provider") != "demo" or (
+            policy is not None and (
+                r["id"] in (getattr(policy, "allowed_routes", None) or [])
+                or "demo" in (getattr(policy, "allowed_transports", None) or [])
+                or "demo" in (getattr(policy, "allowed_providers", None) or [])
+            )
+        )]
+        if not routes:
+            return []
+        from .scoring import filter_and_rank_routes
+        return filter_and_rank_routes(
+            routes=routes,
+            store=self.store,
+            task_name=task_name,
+            policy=policy,
+            seed=task_seed,
+        )
+
+    def record_cost(
+        self,
+        route_id: str,
+        reported_cost: Optional[float],
+        policy: Optional[Any] = None,
+    ) -> None:
+        """Update state from provider-reported cost and trip circuit breaker only when appropriate."""
+        with self._lock:
+            routes = self.data.get("routes", [])
+            target_route = next((r for r in routes if r["id"] == route_id), None)
+
+            is_zero_price_route = False
+            if target_route:
+                if target_route.get("price_state") == PriceState.PRICE_OBSERVED_ZERO.value:
+                    is_zero_price_route = True
+                elif (
+                    target_route.get("cost_per_1k_input") == 0.0
+                    and target_route.get("cost_per_1k_output") == 0.0
+                    and target_route.get("cost_per_1k_input") is not None
+                    and target_route.get("cost_per_1k_output") is not None
+                ):
+                    is_zero_price_route = True
+
+            run_is_free_only = True
+            if policy and (
+                getattr(policy, "max_cost_per_1k_input", 0.0) > 0
+                or getattr(policy, "max_cost_per_1k_output", 0.0) > 0
+                or getattr(policy, "allowed_routes", None)
+            ):
+                run_is_free_only = False
+
+            if reported_cost == 0:
+                if target_route:
+                    if target_route.get("price_state") != PriceState.DISABLED.value:
+                        target_route["price_state"] = PriceState.PRICE_OBSERVED_ZERO.value
+                        target_route["last_price_observation"] = time.time()
+                        self.save()
+                return
+
+            if reported_cost is not None and reported_cost > 0:
+                # If this was admitted as a free route OR the run is strictly free-only:
+                if is_zero_price_route or run_is_free_only:
+                    if target_route:
+                        target_route["enabled"] = False
+                        target_route["price_state"] = PriceState.DISABLED.value
+                        target_route["disabled_reason"] = (
+                            f"Circuit breaker tripped: reported cost {reported_cost} > 0 on free route."
+                        )
+                        target_route["disabled_at"] = time.time()
+                        self.save()
+                    raise RouteCircuitBreaker(
+                        f"Non-zero cost {reported_cost} reported on free route '{route_id}'! Route disabled."
+                    )
+
+                # For paid routes: check per-request spend ceiling if configured in policy
+                max_request_cost = getattr(policy, "max_request_cost", None) if policy else None
+                if max_request_cost is not None and reported_cost > max_request_cost:
+                    if target_route:
+                        target_route["enabled"] = False
+                        target_route["price_state"] = PriceState.DISABLED.value
+                        target_route["disabled_reason"] = (
+                            f"Circuit breaker tripped: reported cost {reported_cost} exceeded policy max_request_cost {max_request_cost}."
+                        )
+                        target_route["disabled_at"] = time.time()
+                        self.save()
+                    raise RouteCircuitBreaker(
+                        f"Request cost {reported_cost} exceeded policy max_request_cost ceiling of {max_request_cost} on '{route_id}'!"
+                    )
+
+                # Record last price observation for the paid route without disabling it
+                if target_route:
+                    target_route["last_price_observation"] = time.time()
+                    self.save()
+
+    def refresh_from_opencode(self) -> int:
+        """Query OpenCode and record candidates separately from observed zero prices."""
+        if not shutil.which("opencode"):
+            raise RuntimeError("opencode CLI not found in PATH")
+
+        res = subprocess.run(
+            ["opencode", "models", "opencode", "--verbose"],
+            capture_output=True,
+            text=True,
+            timeout=30
+        )
+        if res.returncode != 0:
+            raise RuntimeError(f"Failed to query opencode models: {res.stderr}")
+
+        text = res.stdout
+        models = {}
+        decoder = json.JSONDecoder()
+        while text.strip():
+            text = text.lstrip()
+            header, sep, rest = text.partition("\n")
+            if not sep:
+                break
+            if header.startswith("opencode/"):
+                try:
+                    obj, end = decoder.raw_decode(rest.lstrip())
+                    models[header] = obj
+                    text = rest.lstrip()[end:]
+                except Exception:
+                    text = rest
+            else:
+                text = rest
+
+        known = {r["id"]: r for r in self.data.get("routes", [])}
+        discovered_count = 0
+
+        for model_id, model_data in models.items():
+            price_state = classify_price_state(model_data)
+            is_active = model_data.get("status") == "active"
+
+            if model_id in known:
+                r = known[model_id]
+                r["price_state"] = price_state.value
+                r["enabled"] = price_state is PriceState.PRICE_OBSERVED_ZERO and is_active
+                r["last_verified"] = time.strftime("%Y-%m-%d")
+                r["verification_source"] = "opencode models opencode --verbose"
+            elif price_state in {PriceState.CANDIDATE, PriceState.PRICE_OBSERVED_ZERO} and is_active:
+                self.data["routes"].append({
+                    "id": model_id,
+                    "provider": "opencode",
+                    "enabled": price_state is PriceState.PRICE_OBSERVED_ZERO,
+                    "price_state": price_state.value,
+                    "auth": "hosted-free",
+                    "last_verified": time.strftime("%Y-%m-%d"),
+                    "verification_source": "opencode models opencode --verbose"
+                })
+            if price_state in {PriceState.CANDIDATE, PriceState.PRICE_OBSERVED_ZERO}:
+                discovered_count += 1
+
+        self.save()
+        return discovered_count
+
+    def refresh_from_openrouter(self) -> int:
+        """Query OpenRouter and distinguish explicit zero pricing from name candidates."""
+        try:
+            with httpx.Client(timeout=15) as client:
+                resp = client.get("https://openrouter.ai/api/v1/models")
+                if resp.status_code != 200:
+                    raise RuntimeError(f"OpenRouter models API returned HTTP {resp.status_code}")
+                data = resp.json().get("data", [])
+        except Exception as e:
+            raise RuntimeError(f"Failed to fetch OpenRouter models: {e}")
+
+        known = {r["id"]: r for r in self.data.get("routes", [])}
+        discovered_count = 0
+
+        for m in data:
+            price_state = classify_price_state(m)
+            if price_state in {PriceState.CANDIDATE, PriceState.PRICE_OBSERVED_ZERO}:
+                raw_id = m.get("id", "")
+                route_id = f"openrouter/{raw_id}" if not raw_id.startswith("openrouter/") else raw_id
+                
+                if route_id in known:
+                    r = known[route_id]
+                    r["price_state"] = price_state.value
+                    r["enabled"] = price_state is PriceState.PRICE_OBSERVED_ZERO
+                    pricing = m.get("pricing", {})
+                    if price_state is PriceState.PRICE_OBSERVED_ZERO:
+                        r["cost_per_1k_input"] = float(pricing.get("prompt", pricing.get("input", 0))) * 1000
+                        r["cost_per_1k_output"] = float(pricing.get("completion", pricing.get("output", 0))) * 1000
+                    else:
+                        r.pop("cost_per_1k_input", None)
+                        r.pop("cost_per_1k_output", None)
+                    r["last_verified"] = time.strftime("%Y-%m-%d")
+                    r["verification_source"] = "openrouter /api/v1/models pricing"
+                else:
+                    route = {
+                        "id": route_id,
+                        "provider": "openrouter",
+                        "enabled": price_state is PriceState.PRICE_OBSERVED_ZERO,
+                        "price_state": price_state.value,
+                        "auth": "api-key",
+                        "last_verified": time.strftime("%Y-%m-%d"),
+                        "verification_source": "openrouter /api/v1/models pricing"
+                    }
+                    if price_state is PriceState.PRICE_OBSERVED_ZERO:
+                        pricing = m["pricing"]
+                        route["cost_per_1k_input"] = float(pricing.get("prompt", pricing.get("input", 0))) * 1000
+                        route["cost_per_1k_output"] = float(pricing.get("completion", pricing.get("output", 0))) * 1000
+                    self.data["routes"].append(route)
+                discovered_count += 1
+
+        self.save()
+        return discovered_count
+
+    def refresh_all(self) -> Dict[str, int]:
+        """Refresh observed-zero routes and unverified candidates."""
+        results = {}
+        try:
+            results["opencode"] = self.refresh_from_opencode()
+        except Exception as e:
+            results["opencode_error"] = str(e)
+            
+        try:
+            results["openrouter"] = self.refresh_from_openrouter()
+        except Exception as e:
+            results["openrouter_error"] = str(e)
+
+        try:
+            results["openai_compatible"] = self.refresh_from_openai_compatible()
+        except Exception as e:
+            results["openai_compatible_error"] = str(e)
+
+        return results