agentnode-sdk 0.14.0__tar.gz → 0.15.0__tar.gz

{agentnode_sdk-0.14.0 → agentnode_sdk-0.15.0}/CHANGELOG.md

@@ -1,5 +1,49 @@
 # Changelog
 
+## 0.15.0 — Generic OpenAI-compatible LLM providers
+
+### Added
+
+- **Generic OpenAI-compatible provider registry.** The LLM runtime can now
+  bind any endpoint that speaks the OpenAI-compatible protocol. Custom
+  endpoints are plain config entries — `llm.providers.<name>` with
+  `base_url`, `model`, and optionally `api_key_env`/`requires_key` — no code
+  changes needed per provider.
+- **Built-in presets** for OpenRouter, DeepSeek, Mistral, Qwen, Gemini
+  (Google's OpenAI-compatible endpoint) and Ollama, each with the canonical
+  base URL, API-key environment variable, and a sensible default model
+  (overridable via `llm.providers.<name>.model`).
+- **Ollama as a key-free local provider** — the first agent path with no
+  account and no per-token cost. Opt-in only: select it explicitly with
+  `agentnode config set llm.default_provider ollama` (or configure it under
+  `llm.providers`); AgentNode never probes or binds it by surprise.
+- Per-provider credentials: each provider's environment variable (e.g.
+  `DEEPSEEK_API_KEY`, `GEMINI_API_KEY`) and stored vault credentials both
+  work; the environment always overrides the stored key.
+
+### Changed
+
+- The OpenRouter binding now goes through the shared provider registry
+  (same behavior, including the namespaced default model — one code path
+  instead of a special case).
+- The sandboxed-agent LLM broker automatically inherits every compatible
+  provider: keys stay host-side, the container still sees only RPC
+  completions, and the C1/C2 access policy applies unchanged.
+
+### Hardened
+
+- No provider keys in logs or error messages (client failures are reported
+  by exception type only).
+- A custom provider without a configured model is skipped instead of
+  guessing — a wrong default model would fail confusingly at call time.
+- Keyless providers are never attempted unless explicitly selected or
+  configured.
+
+### BREAKING / Upgrade Notes
+
+- None. Existing OpenAI/Anthropic setups (env vars, vault, per-agent config)
+  behave identically; the new providers are purely additive.
+
 ## 0.14.0 — Setup wizard: guided credentials + sandbox onboarding
 
 ### Added

{agentnode_sdk-0.14.0 → agentnode_sdk-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentnode-sdk
-Version: 0.14.0
+Version: 0.15.0
 Summary: Python SDK for AgentNode — the open upgrade and discovery infrastructure for AI agents.
 Project-URL: Homepage, https://agentnode.net
 Project-URL: Repository, https://github.com/agentnode-ai/agentnode

{agentnode_sdk-0.14.0 → agentnode_sdk-0.15.0}/agentnode_sdk/__init__.py

@@ -38,7 +38,7 @@ from agentnode_sdk.runtime import AgentNodeRuntime
 Client = AgentNodeClient
 ToolError = AgentNodeToolError
 
-__version__ = "0.14.0"
+__version__ = "0.15.0"
 __all__ = [
     "AgentNode",
     "AsyncAgentNode",

{agentnode_sdk-0.14.0 → agentnode_sdk-0.15.0}/agentnode_sdk/config.py

@@ -46,6 +46,7 @@ DEFAULTS: dict[str, Any] = {
     },
     "llm": {
         "default_provider": "openai",
+        "providers": {},
     },
 }
 
@@ -68,7 +69,10 @@ VALID_VALUES: dict[str, tuple[str, ...]] = {
     "guard.compute": ("allow", "prompt", "deny"),
     "guard.unknown": ("allow", "prompt", "deny"),
     "agent_sandbox.enabled": ("true", "false"),
-    "llm.default_provider": ("openai", "anthropic", "openrouter"),
+    "llm.default_provider": (
+        "openai", "anthropic", "openrouter", "deepseek", "mistral", "qwen",
+        "gemini", "ollama",
+    ),
 }
 
 
@@ -160,6 +164,10 @@ def _merge_defaults(data: dict) -> dict[str, Any]:
         for k in ("default_provider",):
             if k in data["llm"]:
                 cfg["llm"][k] = data["llm"][k]
+        # llm.providers holds nested endpoint specs (base_url/model/...) —
+        # pass through verbatim, like agent_sandbox.llm above.
+        if isinstance(data["llm"].get("providers"), dict):
+            cfg["llm"]["providers"] = data["llm"]["providers"]
     return cfg
 
 

agentnode_sdk-0.15.0/agentnode_sdk/llm_providers.py

@@ -0,0 +1,116 @@
+"""OpenAI-compatible LLM provider registry (Endpoint-A).
+
+One shared source of truth for the LLM endpoints AgentNode can bind: built-in
+presets (OpenRouter, DeepSeek, Mistral, Qwen, Ollama — plus the official
+OpenAI/Anthropic entries) and user-defined entries/overrides from
+``llm.providers.<name>`` in ~/.agentnode/config.json.
+
+The runtime (``_auto_detect_llm``) builds standard OpenAI-compatible bindings
+from these specs, so the host LLM broker — and therefore sandboxed agents —
+inherit every provider automatically, with the key staying host-side and no
+broker/sandbox change.
+
+Compat presets MUST carry a default model: the broker's bare OpenAI default
+("gpt-4o-mini") would 404 on most compatible endpoints. ``requires_key:
+False`` providers (Ollama) are bound only on explicit selection — never by
+probing.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+# Built-in presets. base_url=None means the provider SDK's official endpoint.
+# default_model="" lets the broker pick its own official default.
+KNOWN_PROVIDERS: dict[str, dict[str, Any]] = {
+    "openai": {
+        "base_url": None,
+        "api_key_env": "OPENAI_API_KEY",
+        "default_model": "",
+        "requires_key": True,
+    },
+    "anthropic": {
+        "base_url": None,
+        "api_key_env": "ANTHROPIC_API_KEY",
+        "default_model": "",
+        "requires_key": True,
+    },
+    "openrouter": {
+        "base_url": "https://openrouter.ai/api/v1",
+        "api_key_env": "OPENROUTER_API_KEY",
+        "default_model": "openai/gpt-4o-mini",
+        "requires_key": True,
+    },
+    "deepseek": {
+        "base_url": "https://api.deepseek.com/v1",
+        "api_key_env": "DEEPSEEK_API_KEY",
+        "default_model": "deepseek-chat",
+        "requires_key": True,
+    },
+    "mistral": {
+        "base_url": "https://api.mistral.ai/v1",
+        "api_key_env": "MISTRAL_API_KEY",
+        "default_model": "mistral-small-latest",
+        "requires_key": True,
+    },
+    "qwen": {
+        "base_url": "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
+        "api_key_env": "DASHSCOPE_API_KEY",
+        "default_model": "qwen-plus",
+        "requires_key": True,
+    },
+    "gemini": {
+        # Google's own OpenAI-compatible endpoint (trailing slash required).
+        "base_url": "https://generativelanguage.googleapis.com/v1beta/openai/",
+        "api_key_env": "GEMINI_API_KEY",
+        "default_model": "gemini-2.0-flash",
+        "requires_key": True,
+    },
+    "ollama": {
+        # key-free local inference: the first agent path with no account and
+        # no per-token cost. Bound ONLY when explicitly selected (no probing).
+        "base_url": "http://localhost:11434/v1",
+        "api_key_env": "OLLAMA_API_KEY",
+        "default_model": "llama3.2",
+        "requires_key": False,
+    },
+}
+
+_SPEC_KEYS = ("base_url", "api_key_env", "default_model", "requires_key")
+
+
+def _config_providers(host_config: dict | None) -> dict:
+    llm = (host_config or {}).get("llm") or {}
+    providers = llm.get("providers")
+    return providers if isinstance(providers, dict) else {}
+
+
+def resolve_provider_spec(name: str, host_config: dict | None = None) -> dict | None:
+    """Effective spec for ``name`` = preset merged with the config override
+    (``llm.providers.<name>``), or None for an unknown name without a config
+    entry. ``model`` is accepted as a friendlier config alias for
+    ``default_model``."""
+    name = (name or "").lower().strip()
+    preset = KNOWN_PROVIDERS.get(name)
+    override = _config_providers(host_config).get(name)
+    if preset is None and not isinstance(override, dict):
+        return None
+
+    spec: dict[str, Any] = dict(preset) if preset else {
+        "base_url": None, "api_key_env": "", "default_model": "", "requires_key": True,
+    }
+    if isinstance(override, dict):
+        for k in _SPEC_KEYS:
+            if k in override:
+                spec[k] = override[k]
+        if "model" in override:
+            spec["default_model"] = override["model"]
+    return spec
+
+
+def known_provider_names(host_config: dict | None = None) -> list[str]:
+    """Preset names first (stable order), then custom config-defined names."""
+    names = list(KNOWN_PROVIDERS)
+    for n in _config_providers(host_config):
+        if n not in names:
+            names.append(n)
+    return names

{agentnode_sdk-0.14.0 → agentnode_sdk-0.15.0}/agentnode_sdk/runtimes/agent_runner.py

@@ -241,64 +241,83 @@ def _create_llm_from_config(llm_config: dict) -> dict | None:
     return None
 
 
-def _llm_binding_from_vault() -> dict | None:
-    """Build an LLM binding from the credential store (UX-2 vault).
-
-    LAST resolution step — env vars always override the store (explicit/CI
-    intent wins; gh-CLI precedent). Tries the configured
-    ``llm.default_provider`` first, then the remaining providers in fixed
-    order. The key stays host-side; failures are logged by exception TYPE
+def _llm_binding_from_providers() -> dict | None:
+    """Build an LLM binding from the provider registry + credential store
+    (UX-2 vault, generalized by Endpoint-A to any OpenAI-compatible endpoint:
+    OpenRouter/DeepSeek/Mistral/Qwen/Ollama/custom ``llm.providers.*``).
+
+    LAST resolution step — the bare OPENAI/ANTHROPIC env vars and per-agent
+    config were already checked by the earlier steps. Within this step the
+    key resolves per provider env-var-first (explicit/CI intent), then vault.
+    Keyless providers (e.g. ollama) bind ONLY when explicitly selected via
+    ``llm.default_provider`` or configured under ``llm.providers`` — never by
+    probing. The key stays host-side; failures are logged by exception TYPE
     only (never the message — it could carry context)."""
+    import os
+
     try:
         from agentnode_sdk.config import load_config
-        default = ((load_config() or {}).get("llm") or {}).get("default_provider", "openai")
+        host_cfg = load_config() or {}
     except Exception:
-        default = "openai"
-    order = [default] + [p for p in ("openai", "anthropic", "openrouter") if p != default]
+        host_cfg = {}
+    llm_cfg = host_cfg.get("llm") or {}
+    default = llm_cfg.get("default_provider", "openai")
+    configured = llm_cfg.get("providers") if isinstance(llm_cfg.get("providers"), dict) else {}
 
     try:
         from agentnode_sdk.credential_store import get_llm_api_key
     except Exception:
         return None
+    from agentnode_sdk.llm_providers import known_provider_names, resolve_provider_spec
 
-    for provider in order:
-        try:
-            key = get_llm_api_key(provider)
-        except Exception:
-            key = None
-        if not key:
+    order = [default] + [n for n in known_provider_names(host_cfg) if n != default]
+    for name in order:
+        spec = resolve_provider_spec(name, host_cfg)
+        if spec is None:
             continue
-        if provider == "openai":
+
+        env_var = spec.get("api_key_env") or ""
+        key = os.environ.get(env_var) if env_var else None  # env beats vault
+        if not key:
             try:
-                from openai import OpenAI
-                return {"client": OpenAI(api_key=key), "provider": "openai", "model": ""}
-            except ImportError:
-                logger.debug("vault key for openai set but openai package not installed")
-            except Exception as exc:
-                logger.debug("Failed to create OpenAI client from vault: %s", type(exc).__name__)
-        elif provider == "anthropic":
+                key = get_llm_api_key(name)
+            except Exception:
+                key = None
+
+        if spec.get("requires_key", True):
+            if not key:
+                continue
+        elif not key and not (name == default or name in configured):
+            # keyless provider without explicit selection: never bind by surprise
+            continue
+
+        if name == "anthropic":
             try:
                 from anthropic import Anthropic
                 return {"client": Anthropic(api_key=key), "provider": "anthropic", "model": ""}
             except ImportError:
-                logger.debug("vault key for anthropic set but anthropic package not installed")
+                logger.debug("key for anthropic set but anthropic package not installed")
             except Exception as exc:
-                logger.debug("Failed to create Anthropic client from vault: %s", type(exc).__name__)
-        elif provider == "openrouter":
-            try:
-                from openai import OpenAI
-                # OpenRouter model ids are namespaced — the broker's bare
-                # "gpt-4o-mini" default would 404 there, so pin the
-                # namespaced equivalent explicitly in the binding.
-                return {
-                    "client": OpenAI(api_key=key, base_url="https://openrouter.ai/api/v1"),
-                    "provider": "openai",
-                    "model": "openai/gpt-4o-mini",
-                }
-            except ImportError:
-                logger.debug("vault key for openrouter set but openai package not installed")
-            except Exception as exc:
-                logger.debug("Failed to create OpenRouter client from vault: %s", type(exc).__name__)
+                logger.debug("Failed to create Anthropic client: %s", type(exc).__name__)
+            continue
+
+        base_url = spec.get("base_url")
+        model = spec.get("default_model") or ""
+        if base_url and not model:
+            # compat endpoint without a model: never guess — the broker's bare
+            # OpenAI default would 404 on most compatible providers.
+            logger.debug("provider %s has a base_url but no model configured — skipped", name)
+            continue
+        try:
+            from openai import OpenAI
+            kwargs: dict = {"api_key": key or "ollama"}
+            if base_url:
+                kwargs["base_url"] = base_url
+            return {"client": OpenAI(**kwargs), "provider": "openai", "model": model}
+        except ImportError:
+            logger.debug("key for %s set but openai package not installed", name)
+        except Exception as exc:
+            logger.debug("Failed to create client for %s: %s", name, type(exc).__name__)
     return None
 
 
@@ -310,8 +329,10 @@ def _auto_detect_llm(slug: str = "") -> dict | None:
     2. ~/.agentnode/.env (loaded into env, no overwrite)
     3. OPENAI_API_KEY -> OpenAI client
     4. ANTHROPIC_API_KEY -> Anthropic client
-    5. Credential store (vault): openai/anthropic/openrouter — env always
-       overrides the store (UX-2)
+    5. Provider registry + credential store (vault): openai/anthropic plus
+       any OpenAI-compatible endpoint (openrouter/deepseek/mistral/qwen/
+       ollama/custom ``llm.providers.*``) — env always overrides the store
+       (UX-2/Endpoint-A)
 
     Returns a dict-style LLM binding {client, provider, model} or None.
     """
@@ -349,7 +370,7 @@ def _auto_detect_llm(slug: str = "") -> dict | None:
         except Exception as exc:
             logger.debug("Failed to create Anthropic client: %s", exc)
 
-    return _llm_binding_from_vault()
+    return _llm_binding_from_providers()
 
 
 # ---------------------------------------------------------------------------

{agentnode_sdk-0.14.0 → agentnode_sdk-0.15.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agentnode-sdk"
-version = "0.14.0"
+version = "0.15.0"
 description = "Python SDK for AgentNode — the open upgrade and discovery infrastructure for AI agents."
 readme = "README.md"
 requires-python = ">=3.10"

{agentnode_sdk-0.14.0 → agentnode_sdk-0.15.0}/tests/test_config.py

@@ -343,3 +343,34 @@ class TestAgentSandboxConfigSection:
         assert loaded["guard"]["delete"] == "deny"
         assert loaded["guard"]["read"] == "allow"          # defaults intact
         assert loaded["trust"]["minimum_trust_level"] == "verified"
+
+
+# --- llm.providers section (Endpoint-A) ---
+
+
+class TestLlmProvidersConfigSection:
+    def test_defaults_include_empty_providers(self):
+        cfg = default_config()
+        assert cfg["llm"]["providers"] == {}
+
+    def test_providers_survive_load(self, isolated_config):
+        providers = {"myvllm": {"base_url": "http://10.0.0.5:8000/v1",
+                                "model": "llama", "requires_key": False}}
+        isolated_config.parent.mkdir(parents=True, exist_ok=True)
+        isolated_config.write_text(
+            json.dumps({"llm": {"default_provider": "deepseek",
+                                "providers": providers}}), encoding="utf-8")
+        loaded = load_config()
+        assert loaded["llm"]["providers"] == providers
+        assert loaded["llm"]["default_provider"] == "deepseek"
+
+    def test_set_value_accepts_new_provider_names(self):
+        cfg = default_config()
+        for name in ("deepseek", "mistral", "qwen", "ollama"):
+            set_value(cfg, "llm.default_provider", name)
+            assert cfg["llm"]["default_provider"] == name
+
+    def test_set_value_rejects_garbage_provider(self):
+        cfg = default_config()
+        with pytest.raises(ValueError):
+            set_value(cfg, "llm.default_provider", "skynet")

agentnode_sdk-0.15.0/tests/test_llm_providers.py

@@ -0,0 +1,79 @@
+"""Endpoint-A — the OpenAI-compatible provider registry."""
+from __future__ import annotations
+
+from agentnode_sdk.llm_providers import (
+    KNOWN_PROVIDERS,
+    known_provider_names,
+    resolve_provider_spec,
+)
+
+
+def test_presets_are_complete():
+    for name, spec in KNOWN_PROVIDERS.items():
+        for key in ("base_url", "api_key_env", "default_model", "requires_key"):
+            assert key in spec, f"{name} missing {key}"
+        # compat endpoints (base_url set) MUST carry a model — the broker's
+        # bare OpenAI default would 404 there
+        if spec["base_url"]:
+            assert spec["default_model"], f"{name} needs a default model"
+
+
+def test_expected_preset_names():
+    for name in ("openai", "anthropic", "openrouter", "deepseek",
+                 "mistral", "qwen", "gemini", "ollama"):
+        assert name in KNOWN_PROVIDERS
+
+
+def test_gemini_uses_googles_openai_compat_endpoint():
+    spec = resolve_provider_spec("gemini")
+    assert spec["base_url"] == "https://generativelanguage.googleapis.com/v1beta/openai/"
+    assert spec["base_url"].endswith("/")          # trailing slash required
+    assert spec["api_key_env"] == "GEMINI_API_KEY"
+    assert spec["default_model"] == "gemini-2.0-flash"
+    assert spec["requires_key"] is True
+
+
+def test_ollama_is_keyless_localhost():
+    spec = resolve_provider_spec("ollama")
+    assert spec["requires_key"] is False
+    assert spec["base_url"] == "http://localhost:11434/v1"
+    assert spec["default_model"]            # never empty (broker default 404s)
+
+
+def test_resolve_preset_without_config():
+    spec = resolve_provider_spec("deepseek")
+    assert spec["base_url"] == "https://api.deepseek.com/v1"
+    assert spec["api_key_env"] == "DEEPSEEK_API_KEY"
+    assert spec["default_model"] == "deepseek-chat"
+
+
+def test_config_override_beats_preset():
+    cfg = {"llm": {"providers": {"deepseek": {
+        "model": "deepseek-reasoner", "base_url": "https://proxy.local/v1"}}}}
+    spec = resolve_provider_spec("deepseek", cfg)
+    assert spec["default_model"] == "deepseek-reasoner"   # "model" alias works
+    assert spec["base_url"] == "https://proxy.local/v1"
+    assert spec["api_key_env"] == "DEEPSEEK_API_KEY"      # preset rest intact
+
+
+def test_custom_provider_from_config_only():
+    cfg = {"llm": {"providers": {"myvllm": {
+        "base_url": "http://10.0.0.5:8000/v1", "model": "llama",
+        "requires_key": False}}}}
+    spec = resolve_provider_spec("myvllm", cfg)
+    assert spec["base_url"] == "http://10.0.0.5:8000/v1"
+    assert spec["default_model"] == "llama"
+    assert spec["requires_key"] is False
+    assert spec["api_key_env"] == ""
+
+
+def test_unknown_provider_is_none():
+    assert resolve_provider_spec("nope") is None
+    assert resolve_provider_spec("") is None
+
+
+def test_known_names_include_custom():
+    cfg = {"llm": {"providers": {"myvllm": {"base_url": "x", "model": "m"}}}}
+    names = known_provider_names(cfg)
+    assert names.index("openai") == 0       # presets first, stable order
+    assert "myvllm" in names