Skip to content

"Vibe-Trading: Your Personal Trading Agent"

5.2 KB
Raw Blame
"""Persistent metadata and OS-vault secrets for custom LLM providers."""

from __future__ import annotations

import json
import re
from datetime import datetime, timezone
from pathlib import Path
from typing import Any
from threading import RLock

from src.config.accessor import get_env_config
from src.config.writer import _write_json_atomically

from src.config.paths import get_runtime_root
from src.trading.credentials import CredentialStore

CONFIG_FILENAME = "custom-llm-providers.json"
STORE_LOCK = RLock()

_ID_RE = re.compile(r"^[a-z0-9][a-z0-9._-]{0,63}$")


class CustomProviderStore:
    """Store custom-provider metadata on disk and API keys in the OS vault."""

    def __init__(self, path: Path | None = None, backend: Any = None) -> None:
        self.path = path or (get_runtime_root() / CONFIG_FILENAME)
        self.credentials = CredentialStore(backend)

    def list_public(self) -> list[dict[str, Any]]:
        payload = self._read()
        profiles = payload.get("profiles", {})
        return [
            {
                "id": profile_id,
                "label": str(item.get("label") or profile_id),
                "base_url": str(item.get("base_url") or ""),
                "model": str(item.get("model") or ""),
                "api_key_configured": self.credentials.status(
                    f"custom-provider:{profile_id}", ["api_key"]
                ).get("api_key", False),
                "active": (get_env_config().llm.langchain_provider == "custom" and payload.get("active_id") == profile_id),
                "last_tested_at": item.get("last_tested_at"),
            }
            for profile_id, item in sorted(profiles.items())
            if isinstance(item, dict)
        ]

    def save(
        self,
        *,
        profile_id: str,
        label: str,
        base_url: str,
        model: str,
        api_key: str,
        last_tested_at: str | None = None,
    ) -> dict[str, Any]:
        """Save tested metadata and vault credentials without changing an active profile."""
        with STORE_LOCK:
            profile_id = profile_id.strip().lower()
            if not _ID_RE.fullmatch(profile_id):
                raise ValueError("Provider id must use lowercase letters, numbers, dot, dash, or underscore")
            if not label.strip() or len(label.strip()) > 100:
                raise ValueError("Provider label must contain 1 to 100 characters")
            if not base_url.strip() or not model.strip() or not api_key.strip():
                raise ValueError("Provider base URL, model, and API key are required")
            payload = self._read()
            profiles = payload.setdefault("profiles", {})
            if payload.get("active_id") == profile_id:
                raise ValueError("Save changes under a new id before activating the updated profile")
            profiles[profile_id] = {
                "label": label.strip(),
                "base_url": base_url.strip().rstrip("/"),
                "model": model.strip(),
                "last_tested_at": last_tested_at or _now(),
            }
            self.credentials.save(f"custom-provider:{profile_id}", {"api_key": api_key.strip()})
            self._write(payload)
            return next(item for item in self.list_public() if item["id"] == profile_id)

    def get(self, profile_id: str) -> dict[str, Any]:
        profile_id = profile_id.strip().lower()
        item = self._read().get("profiles", {}).get(profile_id)
        if not isinstance(item, dict):
            raise ValueError(f"Unknown custom provider profile: {profile_id}")
        api_key = self.credentials.load(f"custom-provider:{profile_id}", ["api_key"]).get("api_key", "")
        if not api_key:
            raise ValueError(f"Custom provider profile has no API key: {profile_id}")
        return {"id": profile_id, **item, "api_key": api_key}

    def activate(self, profile_id: str) -> dict[str, Any]:
        profile = self.get(profile_id)
        payload = self._read()
        payload["active_id"] = profile_id.strip().lower()
        self._write(payload)
        return {key: value for key, value in profile.items() if key != "api_key"}

    def _read(self) -> dict[str, Any]:
        if not self.path.exists():
            return {"profiles": {}, "active_id": None}
        try:
            payload = json.loads(self.path.read_text(encoding="utf-8"))
        except (OSError, UnicodeError, json.JSONDecodeError) as exc:
            raise ValueError(f"Invalid custom provider store: {exc}") from exc
        if not isinstance(payload, dict) or not isinstance(payload.get("profiles"), dict):
            raise ValueError("Invalid custom provider store: profiles must be an object")
        return payload

    def _write(self, payload: dict[str, Any]) -> None:
        _write_json_atomically(self.path, payload)


def _now() -> str:
    return datetime.now(timezone.utc).isoformat()


def active_provider_credentials() -> dict[str, str] | None:
    store = CustomProviderStore()
    payload = store._read()
    active_id = str(payload.get("active_id") or "").strip()
    if not active_id:
        raise RuntimeError("No custom provider is active; select one in Settings")
    profile = store.get(active_id)
    return {key: str(profile[key]) for key in ("base_url", "model", "api_key")}