Hermes Agent sglang model provider plugin

__init__.py

from __future__ import annotations

from copy import deepcopy
from typing import Any

from hermes_cli.config import load_config
from providers import register_provider
from providers.base import ProviderProfile


def _config() -> dict[str, Any]:
    config = load_config() or {}
    return config if isinstance(config, dict) else {}


def _section(name: str) -> dict[str, Any]:
    section = _config().get(name) or {}
    return section if isinstance(section, dict) else {}


def _sglang_config() -> dict[str, Any]:
    return _section("sglang")


def _sglang_value(name: str, default: str = "") -> str:
    value = _sglang_config().get(name)
    if value is None:
        return default
    return str(value).strip()


def _sglang_display_name() -> str:
    return _sglang_value("display_name", "SGLang") or "SGLang"


def _sglang_key_env() -> str:
    return _sglang_value("key_env", "SGLANG_API_KEY") or "SGLANG_API_KEY"


def _sglang_base_url() -> str:
    return _sglang_value("base_url", "").rstrip("/")


def _sglang_api_mode() -> str:
    return _sglang_value("api_mode", "chat_completions") or "chat_completions"


class SGLangProfile(ProviderProfile):
    """OpenAI-compatible SGLang request normalization."""

    def build_extra_body(self, **context: Any) -> dict[str, Any]:
        configured = _sglang_config().get("extra_body")
        return deepcopy(configured) if isinstance(configured, dict) else {}

    def build_api_kwargs_extras(
        self,
        *,
        reasoning_config: dict | None = None,
        **context: Any,
    ) -> tuple[dict[str, Any], dict[str, Any]]:
        extra_body: dict[str, Any] = {}
        top_level: dict[str, Any] = {}

        if not isinstance(reasoning_config, dict):
            return extra_body, top_level

        enabled = reasoning_config.get("enabled", True)
        requested = str(reasoning_config.get("effort") or "").strip().lower()

        if enabled is False or requested == "none":
            top_level["reasoning_effort"] = "none"
            return extra_body, top_level

        translated = {
            "minimal": "low",
            "low": "low",
            "medium": "medium",
            "high": "high",
            "xhigh": "max",
            "max": "max",
        }.get(requested)

        if translated:
            top_level["reasoning_effort"] = translated

        return extra_body, top_level


register_provider(
    SGLangProfile(
        name="sglang",
        aliases=("sgl",),
        display_name=_sglang_display_name(),
        api_mode=_sglang_api_mode(),
        env_vars=(_sglang_key_env(),),
        base_url=_sglang_base_url(),
        auth_type="api_key",
    )
)

instructions.md

Install it like this:

mkdir -p ~/.hermes/plugins/model-providers/sglang
$EDITOR ~/.hermes/plugins/model-providers/sglang/__init__.py
$EDITOR ~/.hermes/plugins/model-providers/sglang/plugin.yaml

Then verify:

python - <<'PY'
from providers import list_providers

p = next(p for p in list_providers() if p.name == "sglang")
print("name:", p.name)
print("display_name:", p.display_name)
print("base_url:", p.base_url)
print("env_vars:", p.env_vars)
print("api_mode:", p.api_mode)
print("extra_body:", p.build_extra_body())
PY

And check Hermes itself:

hermes doctor
hermes model

plugin.yaml

name: sglang
kind: model-provider
version: 0.2.0
description: SGLang OpenAI-compatible provider for Hermes Agent

sample_config.yaml

sglang:
  display_name: spark-885a
  default: qwen3.6-27b-agentic
  api_mode: chat_completions
  base_url: http://spark-885a.local:30000/v1
  key_env: SPARK_885A_API_KEY
  context_length: 262144
  extra_body:
    chat_template_kwargs:
      preserve_thinking: true