monkeybot 2.1.1__py3-none-any.whl

monkeybot/core/config/validation.py

@@ -0,0 +1,249 @@
+"""Provider and deployment configuration validation for monkeybot.yaml."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from monkeybot.core.config.settings import ConfigError, normalize_model_provider
+
+SUPPORTED_MEMORY_BACKENDS = frozenset({"local", "gcs", "drive"})
+SUPPORTED_SECRETS_PROVIDERS = frozenset({"env", "gcp_secret_manager"})
+SUPPORTED_MODEL_PROVIDERS = frozenset(
+    {
+        "google_vertexai",
+        "google_genai",
+        "openai",
+        "anthropic",
+        "vertex_anthropic",
+        "huggingface",
+        "ollama",
+        "nvidia",
+        "fake",
+        "aws_bedrock",
+    }
+)
+
+SUPPORTED_YAML_MODEL_PROVIDERS = frozenset(
+    {
+        "gemini",
+        "vertex",
+        "google_vertexai",
+        "google_genai",
+        "openai",
+        "anthropic",
+        "vertex-claude",
+        "vertex_claude",
+        "vertex_anthropic",
+        "huggingface",
+        "ollama",
+        "nvidia",
+        "fake",
+        "aws_bedrock",
+    }
+)
+
+SUPPORTED_HARNESS_MODES = frozenset({"turn_based", "realtime"})
+SUPPORTED_REALTIME_AUDIO_FORMATS = frozenset(
+    {
+        "pcm_s16le_24khz_mono",
+        "pcm_s16le_16khz_mono",
+    }
+)
+
+
+def validate_provider_env(config: dict[str, str]) -> None:
+    """Validate flattened env-style provider configuration.
+
+    Args:
+        config: Flat env var dict (MODEL_PROVIDER, MEMORY_BACKEND, etc.)
+
+    Raises:
+        ConfigError: If unsupported provider or missing required configuration.
+    """
+    memory_backend = config.get("MEMORY_BACKEND", "local")
+    if memory_backend not in SUPPORTED_MEMORY_BACKENDS:
+        supported = ", ".join(sorted(SUPPORTED_MEMORY_BACKENDS))
+        if memory_backend == "s3":
+            raise ConfigError(
+                f"memory.backend is set to 's3' but AWS S3 is not yet supported.\n\n"
+                f"Currently supported backends: {supported}"
+            )
+        if memory_backend == "azure_blob":
+            raise ConfigError(
+                f"memory.backend is set to 'azure_blob' but Azure Blob Storage is not yet supported.\n\n"
+                f"Currently supported backends: {supported}"
+            )
+        raise ConfigError(
+            f"memory.backend is set to '{memory_backend}' which is not supported.\n"
+            f"Currently supported backends: {supported}"
+        )
+
+    secrets_provider = config.get("SECRETS_PROVIDER", "env")
+    if secrets_provider not in SUPPORTED_SECRETS_PROVIDERS:
+        supported = ", ".join(sorted(SUPPORTED_SECRETS_PROVIDERS))
+        raise ConfigError(
+            f"secrets.provider is set to '{secrets_provider}' which is not supported.\n"
+            f"Currently supported providers: {supported}"
+        )
+
+    model_provider = normalize_model_provider(config.get("MODEL_PROVIDER", "google_vertexai"))
+    if model_provider not in SUPPORTED_MODEL_PROVIDERS:
+        supported = ", ".join(sorted(SUPPORTED_MODEL_PROVIDERS))
+        if model_provider == "azure_openai":
+            raise ConfigError(
+                f"model.provider is set to 'azure_openai' but Azure OpenAI is not yet supported.\n\n"
+                f"Currently supported providers: {supported}"
+            )
+        raise ConfigError(
+            f"model.provider is set to '{model_provider}' which is not supported.\n"
+            f"Currently supported providers: {supported}"
+        )
+
+    gcp_project = (
+        config.get("GCP_PROJECT_ID")
+        or config.get("VERTEX_AI_PROJECT_ID")
+        or config.get("ANTHROPIC_VERTEX_PROJECT_ID")
+        or config.get("GOOGLE_CLOUD_PROJECT")
+        or ""
+    )
+
+    if memory_backend == "gcs" and not gcp_project:
+        raise ConfigError(
+            "memory.backend is set to 'gcs' but gcp.project_id is not configured.\n"
+            "Add 'gcp.project_id: your-project-id' to monkeybot.yaml"
+        )
+
+    if secrets_provider == "gcp_secret_manager" and not gcp_project:
+        raise ConfigError(
+            "secrets.provider is set to 'gcp_secret_manager' but gcp.project_id is not configured.\n"
+            "Add 'gcp.project_id: your-project-id' to monkeybot.yaml"
+        )
+
+    if model_provider == "vertex_anthropic" and not gcp_project:
+        raise ConfigError(
+            "model.provider is set to 'vertex_anthropic' but gcp.project_id is not configured.\n"
+            "Add 'gcp.project_id: your-project-id' to monkeybot.yaml"
+        )
+
+
+def _validate_harness_mode(doc: dict[str, Any]) -> None:
+    """Validate ``harness.mode`` if present. Defaults to ``turn_based``."""
+    harness = doc.get("harness")
+    if not isinstance(harness, dict):
+        return
+    mode = str(harness.get("mode", "turn_based")).strip().lower()
+    if mode not in SUPPORTED_HARNESS_MODES:
+        supported = ", ".join(sorted(SUPPORTED_HARNESS_MODES))
+        raise ConfigError(
+            f"harness.mode is set to '{mode}' which is not supported.\n"
+            f"Supported modes: {supported}"
+        )
+
+
+def _validate_realtime_config(doc: dict[str, Any]) -> None:
+    """Validate ``realtime.*`` settings when ``harness.mode`` is ``realtime``."""
+    harness = doc.get("harness")
+    mode = "turn_based"
+    if isinstance(harness, dict):
+        mode = str(harness.get("mode", "turn_based")).strip().lower()
+
+    realtime_raw = doc.get("realtime")
+    if not isinstance(realtime_raw, dict):
+        realtime_raw = {}
+
+    def _require_positive(path: str, default: int) -> None:
+        parts = path.split(".")
+        value: Any = realtime_raw
+        for part in parts:
+            if not isinstance(value, dict):
+                value = None
+                break
+            value = value.get(part)
+        if value is None:
+            return
+        if not isinstance(value, (int, float)) or value <= 0:
+            raise ConfigError(f"realtime.{path} must be a positive number, got {value!r}")
+
+    # Validate audio format strings even when mode is turn_based so misconfigurations
+    # are caught before the mode is flipped.
+    audio_raw = realtime_raw.get("audio")
+    audio: dict[str, Any] = audio_raw if isinstance(audio_raw, dict) else {}
+    for fmt_key in ("input_format", "output_format"):
+        fmt = str(audio.get(fmt_key, "pcm_s16le_24khz_mono")).strip().lower()
+        if fmt and fmt not in SUPPORTED_REALTIME_AUDIO_FORMATS:
+            supported = ", ".join(sorted(SUPPORTED_REALTIME_AUDIO_FORMATS))
+            raise ConfigError(
+                f"realtime.audio.{fmt_key} is set to '{fmt}' which is not supported.\n"
+                f"Supported formats: {supported}"
+            )
+
+    chunk_ms = audio.get("chunk_ms")
+    if chunk_ms is not None and (not isinstance(chunk_ms, int) or chunk_ms <= 0):
+        raise ConfigError(f"realtime.audio.chunk_ms must be a positive integer, got {chunk_ms!r}")
+
+    _require_positive("audio.max_utterance_sec", 60)
+    _require_positive("session.max_duration_sec", 1800)
+    _require_positive("session.idle_timeout_sec", 120)
+    _require_positive("session.max_response_turn_sec", 300)
+
+    max_concurrent = realtime_raw.get("session", {}).get("max_concurrent_sessions")
+    if max_concurrent is not None and (not isinstance(max_concurrent, int) or max_concurrent <= 0):
+        raise ConfigError(
+            f"realtime.session.max_concurrent_sessions must be a positive integer, "
+            f"got {max_concurrent!r}"
+        )
+
+    if mode != "realtime":
+        return
+
+    # Realtime mode requires the provider to be from the Gemini family for v1.
+    model_raw = doc.get("model")
+    model: dict[str, Any] = model_raw if isinstance(model_raw, dict) else {}
+    provider = str(model.get("provider", "gemini")).strip().lower()
+    if provider not in {"gemini", "vertex", "google_vertexai", "google_genai"}:
+        raise ConfigError(
+            "harness.mode is 'realtime' but model.provider is not a Gemini family provider. "
+            "Realtime v1 only supports google_vertexai or google_genai (Gemini Live)."
+        )
+
+
+def validate_monkeybot_yaml_doc(doc: dict[str, Any], *, env: dict[str, str] | None = None) -> None:
+    """Validate a parsed monkeybot.yaml document (new schema).
+
+    Args:
+        doc: Parsed YAML root mapping.
+        env: Optional environment for GCP project resolution.
+
+    Raises:
+        ConfigError: If unsupported provider or missing required configuration.
+    """
+    env = env or {}
+    model_raw = doc.get("model")
+    model: dict[str, Any] = model_raw if isinstance(model_raw, dict) else {}
+    provider_raw = str(model.get("provider", "gemini")).strip().lower()
+    if provider_raw and provider_raw not in SUPPORTED_YAML_MODEL_PROVIDERS:
+        supported = ", ".join(sorted(SUPPORTED_YAML_MODEL_PROVIDERS))
+        raise ConfigError(
+            f"model.provider is set to '{provider_raw}' which is not supported.\n"
+            f"Currently supported providers: {supported}"
+        )
+
+    _validate_harness_mode(doc)
+    _validate_realtime_config(doc)
+
+    flat: dict[str, str] = {}
+    if isinstance(model, dict) and model.get("provider"):
+        flat["MODEL_PROVIDER"] = str(model["provider"])
+    memory_uri = ""
+    paths = doc.get("paths") if isinstance(doc.get("paths"), dict) else {}
+    if isinstance(paths, dict):
+        memory_uri = str(paths.get("memory_storage_uri", ""))
+    if memory_uri.startswith("gcs://"):
+        flat["MEMORY_BACKEND"] = "gcs"
+    gcp = doc.get("gcp") if isinstance(doc.get("gcp"), dict) else {}
+    if isinstance(gcp, dict) and gcp.get("project_id"):
+        flat["GCP_PROJECT_ID"] = str(gcp["project_id"])
+    for key in ("GCP_PROJECT_ID", "VERTEX_AI_PROJECT_ID", "ANTHROPIC_VERTEX_PROJECT_ID", "GOOGLE_CLOUD_PROJECT"):
+        if key in env and env[key]:
+            flat[key] = env[key]
+    validate_provider_env(flat)

monkeybot/core/config/yaml_loader.py

@@ -0,0 +1,45 @@
+"""Load and merge monkeybot.yaml documents (shared by runtime and subagent registry)."""
+
+from __future__ import annotations
+
+import logging
+import os
+from pathlib import Path
+from typing import Any
+
+from monkeybot.core.config.runtime_env import _load_yaml_file, _merge_with_includes
+
+logger = logging.getLogger(__name__)
+
+
+def resolve_monkeybot_config_path(
+    explicit: str | Path | None = None,
+    *,
+    cwd: Path | None = None,
+) -> Path | None:
+    """Resolve monkeybot.yaml path from explicit arg, MONKEYBOT_CONFIG, or default."""
+    if explicit is not None:
+        p = Path(explicit).expanduser()
+        return p.resolve() if p.is_file() else None
+    env_path = os.environ.get("MONKEYBOT_CONFIG", "").strip()
+    if env_path:
+        p = Path(env_path).expanduser()
+        if p.is_file():
+            return p.resolve()
+        logger.warning("MONKEYBOT_CONFIG is set but not a file: %s", p)
+        return None
+    base = (cwd if cwd is not None else Path.cwd()).expanduser().resolve()
+    default = base / "monkeybot_config" / "monkeybot.yaml"
+    if default.is_file():
+        return default.resolve()
+    return None
+
+
+def load_monkeybot_yaml_dict(config_path: str | Path | None = None) -> tuple[Path | None, dict[str, Any]]:
+    """Load merged monkeybot.yaml (with includes) as a dict."""
+    path = resolve_monkeybot_config_path(config_path)
+    if path is None:
+        return None, {}
+    root = _load_yaml_file(path)
+    merged = _merge_with_includes(path, root)
+    return path, merged