snodo-core 0.7.2__tar.gz

snodo_core-0.7.2/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: snodo-core
+Version: 0.7.2
+Summary: Snodo kernel — core abstractions, config, paths, predicates, sandbox
+Author-email: The Snodo Authors <noreply@snodo.dev>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://snodo.dev
+Project-URL: Repository, https://github.com/snodo-dev/snodo
+Requires-Python: >=3.12
+Requires-Dist: pydantic>=2.12.0

snodo_core-0.7.2/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "snodo-core"
+version = "0.7.2"
+description = "Snodo kernel — core abstractions, config, paths, predicates, sandbox"
+requires-python = ">=3.12"
+license = "Apache-2.0"
+authors = [{ name = "The Snodo Authors", email = "noreply@snodo.dev" }]
+dependencies = [
+    "pydantic>=2.12.0",
+]
+
+[project.urls]
+Homepage = "https://snodo.dev"
+Repository = "https://github.com/snodo-dev/snodo"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["snodo*"]
+
+[tool.setuptools.package-data]
+snodo = ["py.typed"]

snodo_core-0.7.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

snodo_core-0.7.2/src/snodo/config.py

@@ -0,0 +1,546 @@
+"""Configuration and API key management for Snodo.
+
+FILE: snodo/config.py
+
+Manages user configuration stored at ~/.snodo/config.yml:
+- API key storage with secure file permissions (600)
+- Model selection defaults
+- Key validation via liteLLM
+"""
+
+import os
+import stat
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import yaml
+from pydantic import BaseModel, Field
+
+from snodo.paths import resolve_home
+
+
+class ProviderConfig(BaseModel):
+    """Provider configuration with API credential env var and /models endpoint."""
+    api_key: str = ""
+    api_key_env: str = ""
+    models_endpoint: str = ""
+    account_id: str = ""
+    account_id_env: str = ""
+    base_url: str = ""
+    litellm_provider: str = ""
+    extra_headers: Dict[str, str] = Field(default_factory=dict)
+    probe_model: str = ""
+
+
+DEFAULT_PROVIDER_CATALOG: Dict[str, ProviderConfig] = {
+    "anthropic": ProviderConfig(
+        api_key_env="ANTHROPIC_API_KEY",
+        models_endpoint="https://api.anthropic.com/v1/models",
+        probe_model="claude-3-haiku-20240307",
+    ),
+    "openai": ProviderConfig(
+        api_key_env="OPENAI_API_KEY",
+        models_endpoint="https://api.openai.com/v1/models",
+        probe_model="gpt-4o-mini",
+    ),
+    "openrouter": ProviderConfig(
+        api_key_env="OPENROUTER_API_KEY",
+        models_endpoint="https://openrouter.ai/api/v1/models",
+        probe_model="openai/gpt-4o-mini",
+    ),
+    "google": ProviderConfig(
+        api_key_env="GEMINI_API_KEY",
+        models_endpoint="https://generativelanguage.googleapis.com/v1beta/models",
+        probe_model="gemini/gemini-2.0-flash",
+    ),
+    "cloudflare": ProviderConfig(
+        api_key_env="CLOUDFLARE_API_KEY",
+        account_id_env="CLOUDFLARE_ACCOUNT_ID",
+        models_endpoint="https://api.cloudflare.com/client/v4/accounts/{account_id}/ai/v1/models",
+        extra_headers={"x-session-affinity": "{task_id}"},
+        probe_model="@cf/meta/llama-3.1-8b-instruct",
+    ),
+    "deepseek": ProviderConfig(
+        api_key_env="DEEPSEEK_API_KEY",
+        models_endpoint="https://api.deepseek.com/models",
+        probe_model="deepseek/deepseek-chat",
+    ),
+}
+
+
+DEFAULT_MODEL = "claude-sonnet-4-20250514"
+
+
+# Provider-to-model prefix mapping for key resolution
+PROVIDER_MODEL_PREFIXES = {
+    "openai": ["gpt-", "o1-", "o3-"],
+    "anthropic": ["claude-"],
+    "google": ["gemini/", "gemini-"],
+    "cloudflare": ["cloudflare/", "openai/@cf/", "@cf/"],
+    "deepseek": ["deepseek/"],
+}
+
+# Alias map: litellm provider name → snodo config key.
+# litellm.get_llm_provider() returns "gemini" but snodo's config
+# key is "google".  Other names pass through unchanged.
+_PROVIDER_ALIASES: dict[str, str] = {
+    "gemini": "google",
+}
+
+
+def _set_api_key_env(mgr: "ConfigManager", model: str) -> None:
+    """Set API key in environment if available from config."""
+    api_key = mgr.get_key_for_model(model)
+    if api_key:
+        provider_name = ConfigManager._provider_for_model(model)
+        if provider_name:
+            providers = mgr.get_providers()
+            pc = providers.get(provider_name)
+            if pc and pc.api_key_env:
+                os.environ[pc.api_key_env] = api_key
+            if pc and pc.account_id_env and pc.account_id:
+                os.environ[pc.account_id_env] = pc.account_id
+            if pc and pc.litellm_provider:
+                target_pc = DEFAULT_PROVIDER_CATALOG.get(pc.litellm_provider)
+                if target_pc and target_pc.api_key_env:
+                    os.environ[target_pc.api_key_env] = api_key
+
+
+@contextmanager
+def provider_env(model: str):
+    """Injects provider API keys for model into os.environ."""
+    mgr = ConfigManager()
+    _set_api_key_env(mgr, model)
+    try:
+        yield mgr
+    finally:
+        pass  # env vars intentionally left set
+
+
+class ConfigError(Exception):
+    """Configuration error."""
+
+
+class ConfigManager:
+    """Manages Snodo user configuration.
+
+    Config file: ~/.snodo/config.yml
+    Enforces 600 permissions on the config file.
+    """
+
+    def __init__(self, config_dir: Optional[Path] = None):
+        """Initialize config manager.
+
+        Args:
+            config_dir: Override config directory (default: ~/.snodo)
+        """
+        self.config_dir = config_dir or resolve_home()
+        self.config_path = self.config_dir / "config.yml"
+
+    def load(self) -> dict:
+        """Load configuration from disk.
+
+        Returns:
+            Configuration dict (empty dict if file doesn't exist)
+
+        Raises:
+            ConfigError: If config.yml uses the legacy ``api_keys`` format
+                instead of the ``providers`` section.
+        """
+        if not self.config_path.exists():
+            return self._default_config()
+
+        try:
+            with open(self.config_path) as f:
+                data = yaml.safe_load(f) or {}
+        except yaml.YAMLError as e:
+            raise ConfigError(f"Invalid config file: {e}") from e
+
+        # Reject legacy api_keys-only configs — providers is the only schema
+        if data.get("api_keys") and not data.get("providers"):
+            raise ConfigError(
+                "Legacy api_keys config detected. "
+                "Migrate to the providers section. See docs."
+            )
+
+        # Ensure required keys exist
+        data.setdefault("model", DEFAULT_MODEL)
+        data.setdefault("engine", {"max_subtask_depth": 3, "max_session_age_days": 30, "token_ttl_seconds": 600})
+        return data
+
+    def _default_config(self) -> dict:
+        return {
+            "model": DEFAULT_MODEL,
+            "engine": {"max_subtask_depth": 3, "max_session_age_days": 30, "token_ttl_seconds": 600},
+            "cloud": {
+                "api_key": "",
+                "api_url": "https://api.snodo.dev",
+                "sync_enabled": False,
+            },
+            "mcp": {
+                "port": 55441,
+            },
+            "opencode": {
+                "session_token_warning": 150000,
+                "session_reset_on_model_change": False,
+            },
+        }
+
+    def get_providers(self) -> Dict[str, ProviderConfig]:
+        """Return configured providers, merged with defaults.
+
+        Config.yml ``providers`` section overrides default catalog entries.
+        Unlisted providers get their default values.
+        """
+        config = self.load()
+        providers_raw = config.get("providers", {})
+
+        result: Dict[str, ProviderConfig] = {}
+        if isinstance(providers_raw, dict):
+            for name, raw in providers_raw.items():
+                if isinstance(raw, dict):
+                    result[name] = ProviderConfig(**raw)
+
+        # Merge in defaults for providers not in config
+        for name, pc in DEFAULT_PROVIDER_CATALOG.items():
+            if name not in result:
+                result[name] = pc
+        return result
+
+    @staticmethod
+    def resolve_api_base(model: str) -> Optional[str]:
+        """Return the API base URL for *model*'s provider, or ``None``.
+
+        Checks the provider's ``base_url`` in the merged provider config.
+        """
+        provider = ConfigManager._provider_for_model(model)
+        if provider is None:
+            return None
+        pc = ConfigManager().get_providers().get(provider)
+        if pc and pc.base_url:
+            return pc.base_url
+        return None
+
+    @staticmethod
+    def resolve_litellm_provider(model: str) -> Optional[str]:
+        """Return the provider string litellm should route as for *model*."""
+        provider_key = ConfigManager._provider_for_model(model)
+        if not provider_key:
+            return None
+        pc = ConfigManager().get_providers().get(provider_key)
+        if pc and pc.litellm_provider:
+            return pc.litellm_provider
+        return provider_key
+
+    @staticmethod
+    def resolve_litellm_model(model: str) -> str:
+        """Return the model string formatted for litellm completion.
+
+        If a provider specifies a litellm_provider (e.g. litellm_provider="openai"
+        for provider block "ollama"), formats model as "openai/<model_id>" so litellm
+        routes it properly to the OpenAI-compatible endpoint.
+        """
+        provider_key = ConfigManager._provider_for_model(model)
+        if not provider_key:
+            return model
+        pc = ConfigManager().get_providers().get(provider_key)
+        if pc and pc.litellm_provider:
+            if model.startswith(f"{provider_key}/"):
+                raw_id = model[len(provider_key) + 1:]
+            else:
+                raw_id = model
+            return f"{pc.litellm_provider}/{raw_id}"
+        return model
+
+    @staticmethod
+    def resolve_extra_headers(model: str, task_id: Optional[str] = None) -> Optional[Dict[str, str]]:
+        """Return extra headers configured for model's provider.
+
+        Evaluates template variables like ``{task_id}`` in header values.
+        """
+        provider_key = ConfigManager._provider_for_model(model)
+        if not provider_key:
+            return None
+        pc = ConfigManager().get_providers().get(provider_key)
+        if not pc or not pc.extra_headers:
+            return None
+        tid = task_id or "unknown"
+        headers = {}
+        for k, v in pc.extra_headers.items():
+            headers[k] = v.replace("{task_id}", tid)
+        return headers or None
+
+    @staticmethod
+    def _provider_for_model(model: str) -> Optional[str]:
+        """Return the provider (snodo config key) for a model string.
+
+        Checks PROVIDER_MODEL_PREFIXES first, then configured provider block
+        names (e.g. "ollama/llama3" → "ollama"), and falls back to litellm's
+        get_llm_provider().
+        """
+        if not model:
+            return None
+
+        # 1. Match against PROVIDER_MODEL_PREFIXES
+        for provider, prefixes in PROVIDER_MODEL_PREFIXES.items():
+            for prefix in prefixes:
+                if model.startswith(prefix):
+                    return provider
+
+        # 2. Check if model starts with a configured provider key + "/"
+        providers = ConfigManager().get_providers()
+        if "/" in model:
+            prefix = model.split("/")[0]
+            if prefix in providers:
+                return prefix
+
+        # 3. litellm.get_llm_provider()
+        try:
+            from litellm import get_llm_provider
+            _model, provider_name, _, _ = get_llm_provider(model)
+        except Exception:
+            provider_name = None
+
+        if provider_name:
+            aliased = _PROVIDER_ALIASES.get(provider_name, provider_name)
+            if aliased in providers:
+                return aliased
+            return provider_name
+
+        return None
+
+    def save(self, config: dict) -> None:
+        """Save configuration to disk with secure permissions.
+
+        Args:
+            config: Configuration dict to save
+        """
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+
+        with open(self.config_path, "w") as f:
+            yaml.dump(config, f, default_flow_style=False)
+
+        # Set file permissions to 600 (owner read/write only)
+        os.chmod(self.config_path, stat.S_IRUSR | stat.S_IWUSR)
+
+    def add_key(self, provider: str, key: str) -> None:
+        """Store an API key for a provider.
+
+        Args:
+            provider: Provider name (e.g., "openai", "anthropic", "google")
+            key: API key string
+        """
+        if not provider:
+            raise ConfigError("Provider name cannot be empty")
+        if not key:
+            raise ConfigError("API key cannot be empty")
+
+        config = self.load()
+        providers = config.setdefault("providers", {})
+        provider_data = providers.setdefault(provider, {})
+        provider_data["api_key"] = key
+        self.save(config)
+
+    def get_key(self, provider: str) -> Optional[str]:
+        """Get an API key for a provider.
+
+        Args:
+            provider: Provider name
+
+        Returns:
+            API key string, or None if not configured
+        """
+        pc = self.get_providers().get(provider)
+        if pc and pc.api_key:
+            return pc.api_key
+        return None
+
+    def remove_key(self, provider: str) -> bool:
+        """Remove an API key for a provider.
+
+        Args:
+            provider: Provider name
+
+        Returns:
+            True if key was removed, False if it didn't exist
+        """
+        config = self.load()
+        providers_raw = config.get("providers", {})
+        if isinstance(providers_raw, dict):
+            entry = providers_raw.get(provider, {})
+            if isinstance(entry, dict) and "api_key" in entry:
+                del entry["api_key"]
+                self.save(config)
+                return True
+        return False
+
+    def get_key_for_model(self, model: str) -> Optional[str]:
+        """Resolve the API key needed for a given model.
+
+        Args:
+            model: Model identifier (e.g., "claude-sonnet-4-20250514", "gpt-4o")
+
+        Returns:
+            API key string, or None if no matching key found
+        """
+        provider = self._provider_for_model(model)
+        if provider is None:
+            return None
+        return self.get_key(provider)
+
+    def set_model(self, model: str) -> None:
+        """Set the default model.
+
+        Args:
+            model: Model identifier
+        """
+        config = self.load()
+        config["model"] = model
+        self.save(config)
+
+    def get_model(self) -> str:
+        """Get the configured default model.
+
+        Returns:
+            Model identifier
+        """
+        config = self.load()
+        return config.get("default_model") or config.get("model", DEFAULT_MODEL)
+
+    def get_engine_value(self, key: str, default: Any = None) -> Any:
+        """Get an engine configuration value.
+
+        Args:
+            key: Engine config key (e.g., "max_subtask_depth")
+            default: Default value if key not found
+
+        Returns:
+            Config value
+        """
+        config = self.load()
+        return config.get("engine", {}).get(key, default)
+
+    def set_engine_value(self, key: str, value: Any) -> None:
+        """Set an engine configuration value.
+
+        Args:
+            key: Engine config key
+            value: Value to set
+
+        Raises:
+            ValueError: If value fails validation
+        """
+        if key == "max_subtask_depth":
+            if not isinstance(value, int) or value < 1 or value > 10:
+                raise ValueError(f"max_subtask_depth must be an integer between 1 and 10, got {value}")
+        elif key == "max_session_age_days":
+            if not isinstance(value, int) or value < 1 or value > 365:
+                raise ValueError(f"max_session_age_days must be an integer between 1 and 365, got {value}")
+        elif key == "token_ttl_seconds":
+            if not isinstance(value, int) or value < 60 or value > 86400:
+                raise ValueError(f"token_ttl_seconds must be an integer between 60 and 86400, got {value}")
+
+        config = self.load()
+        engine = config.setdefault("engine", {})
+        engine[key] = value
+        self.save(config)
+
+    def test_keys(self) -> Dict[str, str]:
+        """Test all configured API keys via liteLLM.
+
+        Returns:
+            Dict of provider -> result status ("valid", "invalid", "untestable")
+        """
+        results = {}
+        providers = self.get_providers()
+
+        for name, pc in providers.items():
+            key = self.get_key(name)
+            if not key:
+                continue
+            results[name] = self._test_single_key(name, key, pc)
+
+        return results
+
+    def _test_single_key(self, provider: str, key: str, pc: Optional[ProviderConfig] = None) -> str:
+        """Test a single API key by making a minimal LLM call.
+
+        Args:
+            provider: Provider name
+            key: API key to test
+            pc: ProviderConfig with api_key_env and probe_model
+
+        Returns:
+            "valid", "invalid", or "untestable"
+        """
+        if pc is None:
+            pc = self.get_providers().get(provider) or DEFAULT_PROVIDER_CATALOG.get(provider)
+
+        if pc is None or not pc.probe_model:
+            return "untestable"
+
+        model = pc.probe_model
+
+        env_var = pc.api_key_env
+        if not env_var and not pc.litellm_provider:
+            return "untestable"
+
+        try:
+            from litellm import completion
+        except (ImportError, Exception):
+            return "untestable"
+
+        target_env_vars = []
+        if env_var:
+            target_env_vars.append((env_var, key))
+        if pc.litellm_provider:
+            target_pc = DEFAULT_PROVIDER_CATALOG.get(pc.litellm_provider)
+            if target_pc and target_pc.api_key_env:
+                target_env_vars.append((target_pc.api_key_env, key))
+        if pc.account_id_env and pc.account_id:
+            target_env_vars.append((pc.account_id_env, pc.account_id))
+
+        saved_env = {}
+        for ev, val in target_env_vars:
+            saved_env[ev] = os.environ.get(ev)
+            os.environ[ev] = val
+
+        try:
+            kwargs: dict[str, Any] = {
+                "model": ConfigManager.resolve_litellm_model(model),
+                "messages": [{"role": "user", "content": "hi"}],
+                "max_tokens": 1,
+            }
+            api_base = ConfigManager.resolve_api_base(model) or pc.base_url
+            if api_base:
+                kwargs["api_base"] = api_base
+            extra_headers = ConfigManager.resolve_extra_headers(model) or (pc.extra_headers if pc.extra_headers else None)
+            if extra_headers:
+                kwargs["extra_headers"] = extra_headers
+
+            completion(**kwargs)
+            return "valid"
+        except Exception:
+            return "invalid"
+        finally:
+            for ev, _ in target_env_vars:
+                old = saved_env.get(ev)
+                if old is not None:
+                    os.environ[ev] = old
+                elif ev in os.environ:
+                    del os.environ[ev]
+
+    @staticmethod
+    def mask_key(key: str) -> str:
+        """Mask an API key for display, showing only prefix and suffix.
+
+        Args:
+            key: Full API key
+
+        Returns:
+            Masked key (e.g., "sk-ab...xyz")
+        """
+        if len(key) <= 8:
+            return key[:2] + "***"
+        return key[:5] + "***" + key[-3:]

snodo_core-0.7.2/src/snodo/core/__init__.py

@@ -0,0 +1 @@
+""""""