Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
fix(config): validate config files consistently (#904)
Qin Haojie7d9075af168d
diff --git a/openviking/server/bootstrap.py b/openviking/server/bootstrap.pyindex 2665a0308..9362001c8 100644--- a/openviking/server/bootstrap.py+++ b/openviking/server/bootstrap.py@@ -112,8 +112,15 @@ def main():if args.config is not None:os.environ["OPENVIKING_CONFIG_FILE"] = args.config+ from openviking_cli.utils.config.open_viking_config import OpenVikingConfigSingleton+# Load server config from ov.conf- config = load_server_config(args.config)+ try:+ config = load_server_config(args.config)+ OpenVikingConfigSingleton.initialize(config_path=args.config)+ except (FileNotFoundError, ValueError) as e:+ print(e, file=sys.stderr)+ sys.exit(1)# Override with command line argumentsif args.host is not None:diff --git a/openviking/server/config.py b/openviking/server/config.pyindex e50649f7a..5995876f4 100644--- a/openviking/server/config.py+++ b/openviking/server/config.py@@ -3,14 +3,16 @@"""Server configuration for OpenViking HTTP Server."""import sys-from dataclasses import dataclass, fieldfrom typing import List, Optional+from pydantic import BaseModel, Field, ValidationError+from openviking_cli.utils import get_loggerfrom openviking_cli.utils.config.config_loader import (load_json_config,resolve_config_path,)+from openviking_cli.utils.config.config_utils import format_validation_errorfrom openviking_cli.utils.config.consts import (DEFAULT_CONFIG_DIR,DEFAULT_OV_CONF,@@ -21,22 +23,23 @@ from openviking_cli.utils.config.consts import (logger = get_logger(__name__)-@dataclass-class PrometheusConfig:+class PrometheusConfig(BaseModel):"""Prometheus exporter configuration."""enabled: bool = False+ model_config = {"extra": "forbid"}+-@dataclass-class TelemetryConfig:+class TelemetryConfig(BaseModel):"""Telemetry configuration."""- prometheus: PrometheusConfig = field(default_factory=PrometheusConfig)+ prometheus: PrometheusConfig = Field(default_factory=PrometheusConfig)++ model_config = {"extra": "forbid"}-@dataclass-class ServerConfig:+class ServerConfig(BaseModel):"""Server configuration (from the ``server`` section of ov.conf)."""host: str = "127.0.0.1"@@ -44,11 +47,13 @@ class ServerConfig:workers: int = 1auth_mode: str = "api_key"root_api_key: Optional[str] = None- cors_origins: List[str] = field(default_factory=lambda: ["*"])+ cors_origins: List[str] = Field(default_factory=lambda: ["*"])with_bot: bool = False # Enable Bot API proxy to Vikingbotbot_api_url: str = "http://localhost:18790" # Vikingbot OpenAPIChannel URL (default port)encryption_enabled: bool = False # Whether API key hashing is enabled- telemetry: TelemetryConfig = field(default_factory=TelemetryConfig)+ telemetry: TelemetryConfig = Field(default_factory=TelemetryConfig)++ model_config = {"extra": "forbid"}def load_server_config(config_path: Optional[str] = None) -> ServerConfig:@@ -84,28 +89,23 @@ def load_server_config(config_path: Optional[str] = None) -> ServerConfig:data = load_json_config(path)server_data = data.get("server", {})- telemetry_data = server_data.get("telemetry", {}) or {}- prometheus_data = telemetry_data.get("prometheus", {}) or {}+ if server_data is None:+ server_data = {}+ if not isinstance(server_data, dict):+ raise ValueError("Invalid server config: 'server' section must be an object")# Get encryption enabled from config data directly (for test compatibility)encryption_enabled = data.get("encryption", {}).get("enabled", False)- config = ServerConfig(- host=server_data.get("host", "127.0.0.1"),- port=server_data.get("port", 1933),- workers=server_data.get("workers", 1),- auth_mode=server_data.get("auth_mode", "api_key"),- root_api_key=server_data.get("root_api_key"),- cors_origins=server_data.get("cors_origins", ["*"]),- encryption_enabled=encryption_enabled,- telemetry=TelemetryConfig(- prometheus=PrometheusConfig(- enabled=prometheus_data.get("enabled", False),- )- ),- )+ try:+ config = ServerConfig.model_validate(server_data)+ except ValidationError as e:+ raise ValueError(+ f"Invalid server config in {path}:\n"+ f"{format_validation_error(root_model=ServerConfig, error=e, path_prefix='server')}"+ ) from e- return config+ return config.model_copy(update={"encryption_enabled": encryption_enabled})_LOCALHOST_HOSTS = {"127.0.0.1", "localhost", "::1"}diff --git a/openviking_cli/client/http.py b/openviking_cli/client/http.pyindex 50cf16c43..ac091c43b 100644--- a/openviking_cli/client/http.py+++ b/openviking_cli/client/http.py@@ -35,14 +35,7 @@ from openviking_cli.exceptions import (from openviking_cli.retrieve.types import FindResultfrom openviking_cli.session.user_id import UserIdentifierfrom openviking_cli.utils import run_async-from openviking_cli.utils.config.config_loader import (- load_json_config,- resolve_config_path,-)-from openviking_cli.utils.config.consts import (- DEFAULT_OVCLI_CONF,- OPENVIKING_CLI_CONFIG_ENV,-)+from openviking_cli.utils.config.ovcli_config import load_ovcli_configfrom openviking_cli.utils.uri import VikingURI# Error code to exception class mapping@@ -151,20 +144,24 @@ class AsyncHTTPClient(BaseClient):to access tenant-scoped APIs. If not provided, reads from ovcli.conf.timeout: HTTP request timeout in seconds. Default 60.0."""- if url is None:- # print(f"OPENVIKING_CLI_CONFIG_ENV={OPENVIKING_CLI_CONFIG_ENV}")- # print(f"DEFAULT_OVCLI_CONF={DEFAULT_OVCLI_CONF}")- config_path = resolve_config_path(None, OPENVIKING_CLI_CONFIG_ENV, DEFAULT_OVCLI_CONF)- if config_path:- cfg = load_json_config(config_path)-- url = cfg.get("url")- api_key = api_key or cfg.get("api_key")- agent_id = agent_id or cfg.get("agent_id")- account = account or cfg.get("account")- user = user or cfg.get("user")+ should_load_cli_config = (+ url is None+ or api_key is None+ or agent_id is None+ or account is None+ or user is None+ or timeout == 60.0+ )+ if should_load_cli_config:+ cli_config = load_ovcli_config()+ if cli_config is not None:+ url = url or cli_config.url+ api_key = api_key or cli_config.api_key+ agent_id = agent_id or cli_config.agent_id+ account = account or cli_config.account+ user = user or cli_config.userif timeout == 60.0: # only override default with config value- timeout = cfg.get("timeout", 60.0)+ timeout = cli_config.timeoutif not url:raise ValueError("url is required. Pass it explicitly or configure in "diff --git a/openviking_cli/utils/config/__init__.py b/openviking_cli/utils/config/__init__.pyindex 01737a20f..15ef612af 100644--- a/openviking_cli/utils/config/__init__.py+++ b/openviking_cli/utils/config/__init__.py@@ -24,6 +24,7 @@ from .open_viking_config import (is_valid_openviking_config,set_openviking_config,)+from .ovcli_config import OVCLIConfig, load_ovcli_configfrom .parser_config import (PARSER_CONFIG_REGISTRY,AudioConfig,@@ -54,6 +55,7 @@ __all__ = ["OPENVIKING_CONFIG_ENV","OpenVikingConfig","OpenVikingConfigSingleton",+ "OVCLIConfig","RerankConfig","StorageConfig","VectorDBBackendConfig",@@ -73,6 +75,7 @@ __all__ = ["get_openviking_config","initialize_openviking_config","load_json_config",+ "load_ovcli_config","require_config","resolve_config_path","set_openviking_config",diff --git a/openviking_cli/utils/config/config_utils.py b/openviking_cli/utils/config/config_utils.pynew file mode 100644index 000000000..36d60330b--- /dev/null+++ b/openviking_cli/utils/config/config_utils.py@@ -0,0 +1,116 @@+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.+# SPDX-License-Identifier: Apache-2.0+"""Shared helpers for config validation and error formatting."""++import difflib+from typing import Any, Optional, get_args, get_origin++from pydantic import BaseModel, ValidationError+++def suggest_closest_field(field_name: str, valid_fields: set[str]) -> Optional[str]:+ """Return the closest matching field name when it is similar enough."""+ close_matches = difflib.get_close_matches(field_name, sorted(valid_fields), n=1, cutoff=0.6)+ if close_matches:+ return close_matches[0]+ return None+++def raise_unknown_config_fields(+ *,+ data: dict[str, Any],+ valid_fields: set[str],+ context_name: str,+) -> None:+ """Raise a user-friendly error for unexpected config fields."""+ unknown_fields = [key for key in data if key not in valid_fields]+ if not unknown_fields:+ return++ errors = []+ for field_name in unknown_fields:+ suggestion = suggest_closest_field(field_name, valid_fields)+ if suggestion:+ errors.append(+ f"Unknown config field '{field_name}' in {context_name} "+ f"(did you mean '{suggestion}'?)"+ )+ else:+ errors.append(f"Unknown config field '{field_name}' in {context_name}")++ raise ValueError("\n".join(errors))+++def _unwrap_model_type(annotation: Any) -> Optional[type[BaseModel]]:+ if isinstance(annotation, type) and issubclass(annotation, BaseModel):+ return annotation++ origin = get_origin(annotation)+ if origin is None:+ return None++ for arg in get_args(annotation):+ model_type = _unwrap_model_type(arg)+ if model_type is not None:+ return model_type+ return None+++def _get_model_at_path(+ root_model: type[BaseModel], path: tuple[Any, ...]+) -> Optional[type[BaseModel]]:+ current_model = root_model+ for part in path:+ field = current_model.model_fields.get(str(part))+ if field is None:+ return None+ next_model = _unwrap_model_type(field.annotation)+ if next_model is None:+ return None+ current_model = next_model+ return current_model+++def format_validation_error(+ *,+ root_model: type[BaseModel],+ error: ValidationError,+ path_prefix: str = "",+) -> str:+ """Render a pydantic ValidationError as a concise config error message."""+ formatted_errors = []++ for item in error.errors():+ loc = tuple(item.get("loc", ()))+ path_parts = [path_prefix] if path_prefix else []+ path_parts.extend(str(part) for part in loc)+ path = ".".join(path_parts)+ error_type = item.get("type", "")++ if error_type == "extra_forbidden" and loc:+ parent_model = _get_model_at_path(root_model, loc[:-1])+ invalid_field = str(loc[-1])+ message = f"Unknown config field '{path}'" if path else "Unknown config field"++ if parent_model is not None:+ suggestion = suggest_closest_field(+ invalid_field,+ set(parent_model.model_fields.keys()),+ )+ if suggestion:+ suggested_parts = [path_prefix] if path_prefix else []+ suggested_parts.extend(str(part) for part in loc[:-1])+ suggested_parts.append(suggestion)+ message += f" (did you mean '{'.'.join(suggested_parts)}'?)"++ formatted_errors.append(message)+ continue++ if path:+ formatted_errors.append(+ f"Invalid value for '{path}': {item.get('msg', 'validation failed')}"+ )+ else:+ formatted_errors.append(f"Invalid config value: {item.get('msg', 'validation failed')}")++ return "\n".join(formatted_errors)diff --git a/openviking_cli/utils/config/open_viking_config.py b/openviking_cli/utils/config/open_viking_config.pyindex 1eb16aa23..d83ba2117 100644--- a/openviking_cli/utils/config/open_viking_config.py+++ b/openviking_cli/utils/config/open_viking_config.py@@ -5,11 +5,12 @@ from pathlib import Pathfrom threading import Lockfrom typing import Any, Dict, Optional-from pydantic import BaseModel, Field+from pydantic import BaseModel, Field, ValidationErrorfrom openviking_cli.session.user_id import UserIdentifierfrom .config_loader import resolve_config_path+from .config_utils import format_validation_error, raise_unknown_config_fieldsfrom .consts import (DEFAULT_CONFIG_DIR,DEFAULT_OV_CONF,@@ -103,7 +104,8 @@ class OpenVikingConfig(BaseModel):)feishu: FeishuConfig = Field(- default_factory=lambda: FeishuConfig(), description="Feishu/Lark document parsing configuration"+ default_factory=lambda: FeishuConfig(),+ description="Feishu/Lark document parsing configuration",)semantic: SemanticConfig = Field(@@ -147,49 +149,67 @@ class OpenVikingConfig(BaseModel):@classmethoddef from_dict(cls, config: Dict[str, Any]) -> "OpenVikingConfig":"""Create configuration from dictionary."""- # Make a copy to avoid modifying the original- config_copy = config.copy()-- # Remove sections managed by other loaders (e.g. server config)- config_copy.pop("server", None)- config_copy.pop("bot", None)-- # Handle parser configurations from nested "parsers" section- parser_configs = {}- if "parsers" in config_copy:- parser_configs = config_copy.pop("parsers")- parser_types = [- "pdf",- "code",- "image",- "audio",- "video",- "markdown",- "html",- "text",- "directory",- "feishu",- ]- for parser_type in parser_types:- if parser_type in config_copy:- parser_configs[parser_type] = config_copy.pop(parser_type)- # Handle log configuration from nested "log" section- log_config_data = None- if "log" in config_copy:- log_config_data = config_copy.pop("log")-- instance = cls(**config_copy)- # Apply log configuration- if log_config_data is not None:- instance.log = LogConfig.from_dict(log_config_data)-- # Apply parser configurations- for parser_type, parser_data in parser_configs.items():- if hasattr(instance, parser_type):- config_class = getattr(instance, parser_type).__class__- setattr(instance, parser_type, config_class.from_dict(parser_data))-- return instance+ try:+ # Make a copy to avoid modifying the original+ config_copy = config.copy()++ parser_types = [+ "pdf",+ "code",+ "image",+ "audio",+ "video",+ "markdown",+ "html",+ "text",+ "directory",+ "feishu",+ ]+ raise_unknown_config_fields(+ data=config_copy,+ valid_fields=set(cls.model_fields.keys()) | {"server", "bot", "parsers"},+ context_name="OpenVikingConfig",+ )++ # Remove sections managed by other loaders (e.g. server config)+ config_copy.pop("server", None)+ config_copy.pop("bot", None)++ # Handle parser configurations from nested "parsers" section+ parser_configs = {}+ if "parsers" in config_copy:+ parser_configs = config_copy.pop("parsers")+ if parser_configs is None:+ parser_configs = {}+ if not isinstance(parser_configs, dict):+ raise ValueError("Invalid parsers config: 'parsers' section must be an object")+ raise_unknown_config_fields(+ data=parser_configs,+ valid_fields=set(parser_types),+ context_name="parsers",+ )+ for parser_type in parser_types:+ if parser_type in config_copy:+ parser_configs[parser_type] = config_copy.pop(parser_type)+ # Handle log configuration from nested "log" section+ log_config_data = None+ if "log" in config_copy:+ log_config_data = config_copy.pop("log")++ instance = cls(**config_copy)+ # Apply log configuration+ if log_config_data is not None:+ instance.log = LogConfig.from_dict(log_config_data)++ # Apply parser configurations+ for parser_type, parser_data in parser_configs.items():+ if hasattr(instance, parser_type):+ config_class = getattr(instance, parser_type).__class__+ setattr(instance, parser_type, config_class.from_dict(parser_data))++ return instance+ except ValidationError as e:+ raise ValueError(format_validation_error(root_model=cls, error=e)) from edef to_dict(self) -> Dict[str, Any]:"""Convert configuration to dictionary."""@@ -275,6 +295,8 @@ class OpenVikingConfigSingleton:return OpenVikingConfig.from_dict(config_data)except json.JSONDecodeError as e:raise ValueError(f"Config file JSON format error: {e}")+ except ValueError:+ raiseexcept Exception as e:raise RuntimeError(f"Failed to load config file: {e}")diff --git a/openviking_cli/utils/config/ovcli_config.py b/openviking_cli/utils/config/ovcli_config.pynew file mode 100644index 000000000..08ffff6fd--- /dev/null+++ b/openviking_cli/utils/config/ovcli_config.py@@ -0,0 +1,43 @@+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.+# SPDX-License-Identifier: Apache-2.0+"""Configuration schema and loader for ovcli.conf."""++from pathlib import Path+from typing import Optional++from pydantic import BaseModel, ValidationError++from .config_loader import resolve_config_path+from .config_utils import format_validation_error+from .consts import DEFAULT_OVCLI_CONF, OPENVIKING_CLI_CONFIG_ENV+++class OVCLIConfig(BaseModel):+ """Client configuration loaded from ovcli.conf."""++ url: Optional[str] = None+ api_key: Optional[str] = None+ agent_id: Optional[str] = None+ account: Optional[str] = None+ user: Optional[str] = None+ timeout: float = 60.0++ model_config = {"extra": "forbid"}+++def load_ovcli_config(config_path: Optional[str] = None) -> Optional[OVCLIConfig]:+ """Load ovcli.conf if present and validate it strictly."""+ path = resolve_config_path(config_path, OPENVIKING_CLI_CONFIG_ENV, DEFAULT_OVCLI_CONF)+ if path is None:+ return None++ try:+ from .config_loader import load_json_config++ data = load_json_config(Path(path))+ return OVCLIConfig.model_validate(data)+ except ValidationError as e:+ raise ValueError(+ f"Invalid CLI config in {path}:\n"+ f"{format_validation_error(root_model=OVCLIConfig, error=e, path_prefix='ovcli')}"+ ) from ediff --git a/openviking_cli/utils/config/parser_config.py b/openviking_cli/utils/config/parser_config.pyindex ce42815ae..abd805c53 100644--- a/openviking_cli/utils/config/parser_config.py+++ b/openviking_cli/utils/config/parser_config.py@@ -12,6 +12,8 @@ from dataclasses import dataclassfrom pathlib import Pathfrom typing import Any, Dict, Optional, Union+from .config_utils import raise_unknown_config_fields+@dataclassclass ParserConfig:@@ -58,33 +60,9 @@ class ParserConfig:Examples:>>> config = ParserConfig.from_dict({"max_content_length": 50000})"""- import logging- import difflib-- logger = logging.getLogger(__name__)-- # Filter only fields that belong to this classvalid_fields = {f.name for f in cls.__dataclass_fields__.values()}- unknown_fields = {k: v for k, v in data.items() if k not in valid_fields}-- if unknown_fields:- warnings = []- for field_name in unknown_fields:- close_matches = difflib.get_close_matches(field_name, valid_fields, n=1, cutoff=0.6)- if close_matches:- warnings.append(- f"Unknown config field '{field_name}' in {cls.__name__} — "- f"did you mean '{close_matches[0]}'?"- )- else:- warnings.append(- f"Unknown config field '{field_name}' in {cls.__name__} — ignoring"- )- for w in warnings:- logger.warning(w)-- filtered_data = {k: v for k, v in data.items() if k in valid_fields}- return cls(**filtered_data)+ raise_unknown_config_fields(data=data, valid_fields=valid_fields, context_name=cls.__name__)+ return cls(**data)@classmethoddef from_yaml(cls, yaml_path: Union[str, Path]) -> "ParserConfig":@@ -518,8 +496,12 @@ class FeishuConfig(ParserConfig):domain: str = "https://open.feishu.cn"max_rows_per_sheet: int = 1000max_records_per_table: int = 1000- download_images: bool = True # TODO: not yet implemented, reserved for future image download support- request_timeout: float = 30.0 # TODO: not yet passed to lark-oapi client, reserved for future use+ download_images: bool = (+ True # TODO: not yet implemented, reserved for future image download support+ )+ request_timeout: float = (+ 30.0 # TODO: not yet passed to lark-oapi client, reserved for future use+ )@dataclass@@ -644,6 +626,12 @@ def load_parser_configs_from_dict(config_dict: Dict[str, Any]) -> Dict[str, Pars>>> pdf_config = configs["pdf"]>>> code_config = configs["code"]"""+ raise_unknown_config_fields(+ data=config_dict,+ valid_fields=set(PARSER_CONFIG_REGISTRY.keys()),+ context_name="parsers",+ )+configs = {}for parser_type, config_class in PARSER_CONFIG_REGISTRY.items():diff --git a/tests/client/test_http_client_config.py b/tests/client/test_http_client_config.pynew file mode 100644index 000000000..ed6cb5a71--- /dev/null+++ b/tests/client/test_http_client_config.py@@ -0,0 +1,79 @@+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.+# SPDX-License-Identifier: Apache-2.0++import json++import pytest++from openviking_cli.client.http import AsyncHTTPClient+++def test_async_http_client_loads_missing_fields_from_ovcli_config(tmp_path, monkeypatch):+ config_path = tmp_path / "ovcli.conf"+ config_path.write_text(+ json.dumps(+ {+ "url": "http://config-host:1933",+ "api_key": "config-key",+ "agent_id": "config-agent",+ "account": "config-account",+ "user": "config-user",+ "timeout": 12.5,+ }+ )+ )+ monkeypatch.setenv("OPENVIKING_CLI_CONFIG_FILE", str(config_path))++ client = AsyncHTTPClient(url="http://explicit-host:1933")++ assert client._url == "http://explicit-host:1933"+ assert client._api_key == "config-key"+ assert client._agent_id == "config-agent"+ assert client._account == "config-account"+ assert client._user_id == "config-user"+ assert client._timeout == 12.5+++def test_async_http_client_explicit_values_override_ovcli_config(tmp_path, monkeypatch):+ config_path = tmp_path / "ovcli.conf"+ config_path.write_text(+ json.dumps(+ {+ "url": "http://config-host:1933",+ "api_key": "config-key",+ "account": "config-account",+ "timeout": 12.5,+ }+ )+ )+ monkeypatch.setenv("OPENVIKING_CLI_CONFIG_FILE", str(config_path))++ client = AsyncHTTPClient(+ url="http://explicit-host:1933",+ api_key="explicit-key",+ account="explicit-account",+ timeout=33.0,+ )++ assert client._url == "http://explicit-host:1933"+ assert client._api_key == "explicit-key"+ assert client._account == "explicit-account"+ assert client._timeout == 33.0+++def test_async_http_client_rejects_unknown_ovcli_field(tmp_path, monkeypatch):+ config_path = tmp_path / "ovcli.conf"+ config_path.write_text(json.dumps({"ur": "http://localhost:1933"}))+ monkeypatch.setenv("OPENVIKING_CLI_CONFIG_FILE", str(config_path))++ with pytest.raises(ValueError, match=r"ovcli\.ur'.*ovcli\.url"):+ AsyncHTTPClient()+++def test_async_http_client_reports_invalid_ovcli_value_path(tmp_path, monkeypatch):+ config_path = tmp_path / "ovcli.conf"+ config_path.write_text(json.dumps({"url": "http://localhost:1933", "timeout": "fast"}))+ monkeypatch.setenv("OPENVIKING_CLI_CONFIG_FILE", str(config_path))++ with pytest.raises(ValueError, match=r"Invalid value for 'ovcli\.timeout'"):+ AsyncHTTPClient()diff --git a/tests/parse/test_markdown_char_limit.py b/tests/parse/test_markdown_char_limit.pyindex c41f0357f..502542f45 100644--- a/tests/parse/test_markdown_char_limit.py+++ b/tests/parse/test_markdown_char_limit.py@@ -7,7 +7,7 @@ from unittest.mock import AsyncMock, MagicMock, patchimport pytestfrom openviking.parse.parsers.markdown import MarkdownParser-from openviking_cli.utils.config.parser_config import ParserConfig+from openviking_cli.utils.config.parser_config import ParserConfig, load_parser_configs_from_dict# ---------------------------------------------------------------------------# ParserConfig@@ -31,6 +31,14 @@ class TestParserConfigMaxSectionChars:config = ParserConfig.from_dict({})assert config.max_section_chars == 6000+ def test_from_dict_rejects_unknown_key(self):+ with pytest.raises(ValueError, match="max_section_chars"):+ ParserConfig.from_dict({"max_section_chras": 2000})++ def test_load_parser_configs_rejects_unknown_parser_section(self):+ with pytest.raises(ValueError, match="markdown"):+ load_parser_configs_from_dict({"markdwon": {}})+def test_validate_rejects_zero(self):config = ParserConfig(max_section_chars=0)with pytest.raises(ValueError, match="max_section_chars"):diff --git a/tests/test_config_loader.py b/tests/test_config_loader.pyindex b8e9b1d13..db86305cb 100644--- a/tests/test_config_loader.py+++ b/tests/test_config_loader.py@@ -98,3 +98,76 @@ class TestRequireConfig:monkeypatch.delenv("TEST_MISSING_ENV", raising=False)with pytest.raises(FileNotFoundError, match="configuration file not found"):require_config(None, "TEST_MISSING_ENV", "nonexistent_file.conf", "test")+++def test_openviking_config_rejects_unknown_nested_parser_section(monkeypatch):+ monkeypatch.setenv("OPENVIKING_CONFIG_FILE", "/tmp/codex-no-config.json")++ from openviking_cli.utils.config.open_viking_config import (+ OpenVikingConfig,+ OpenVikingConfigSingleton,+ )++ with pytest.raises(ValueError, match="markdown"):+ OpenVikingConfig.from_dict(+ {+ "embedding": {+ "dense": {+ "provider": "openai",+ "api_key": "test-key",+ "model": "text-embedding-3-small",+ }+ },+ "parsers": {"markdwon": {}},+ }+ )++ OpenVikingConfigSingleton.reset_instance()+++def test_openviking_config_rejects_unknown_top_level_section_with_suggestion(monkeypatch):+ monkeypatch.setenv("OPENVIKING_CONFIG_FILE", "/tmp/codex-no-config.json")++ from openviking_cli.utils.config.open_viking_config import (+ OpenVikingConfig,+ OpenVikingConfigSingleton,+ )++ with pytest.raises(+ ValueError, match=r"Unknown config field 'erver' in OpenVikingConfig .*'server'"+ ):+ OpenVikingConfig.from_dict(+ {+ "erver": {+ "host": "127.0.0.1",+ "port": 1933,+ "root_api_key": "test",+ "cors_origins": ["*"],+ },+ "embedding": {+ "dense": {+ "provider": "openai",+ "api_key": "test-key",+ "model": "text-embedding-3-small",+ }+ },+ }+ )++ OpenVikingConfigSingleton.reset_instance()+++def test_openviking_config_singleton_preserves_value_error_for_bad_config(tmp_path, monkeypatch):+ monkeypatch.setenv("OPENVIKING_CONFIG_FILE", "/tmp/codex-no-config.json")++ from openviking_cli.utils.config.open_viking_config import OpenVikingConfigSingleton++ config_path = tmp_path / "ov.conf"+ config_path.write_text(+ '{"erver": {"host": "127.0.0.1"}, "embedding": {"dense": {"provider": "openai", "api_key": "x", "model": "m"}}}'+ )++ OpenVikingConfigSingleton.reset_instance()+ with pytest.raises(ValueError, match="server"):+ OpenVikingConfigSingleton.initialize(config_path=str(config_path))+ OpenVikingConfigSingleton.reset_instance()diff --git a/tests/test_server_config_loader.py b/tests/test_server_config_loader.pynew file mode 100644index 000000000..ef7a69d55--- /dev/null+++ b/tests/test_server_config_loader.py@@ -0,0 +1,69 @@+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.+# SPDX-License-Identifier: Apache-2.0++import json++import pytest++from openviking.server.config import load_server_config+++def test_load_server_config_rejects_unknown_field(tmp_path):+ config_path = tmp_path / "ov.conf"+ config_path.write_text(json.dumps({"server": {"host": "0.0.0.0", "prt": 9999}}))++ with pytest.raises(+ ValueError,+ match=r"server\.prt'.*server\.port",+ ):+ load_server_config(str(config_path))+++def test_load_server_config_rejects_unknown_nested_field(tmp_path):+ config_path = tmp_path / "ov.conf"+ config_path.write_text(json.dumps({"server": {"telemetry": {"prometheus": {"enabld": True}}}}))++ with pytest.raises(+ ValueError,+ match=r"server\.telemetry\.prometheus\.enabld'.*server\.telemetry\.prometheus\.enabled",+ ):+ load_server_config(str(config_path))+++def test_load_server_config_reports_invalid_value_path(tmp_path):+ config_path = tmp_path / "ov.conf"+ config_path.write_text(json.dumps({"server": {"port": "abc"}}))++ with pytest.raises(ValueError, match=r"Invalid value for 'server\.port'"):+ load_server_config(str(config_path))+++def test_load_server_config_preserves_supported_fields(tmp_path):+ config_path = tmp_path / "ov.conf"+ config_path.write_text(+ json.dumps(+ {+ "server": {+ "host": "0.0.0.0",+ "port": 1944,+ "workers": 2,+ "auth_mode": "trusted",+ "with_bot": True,+ "bot_api_url": "http://localhost:19999",+ "telemetry": {"prometheus": {"enabled": True}},+ },+ "encryption": {"enabled": True},+ }+ )+ )++ config = load_server_config(str(config_path))++ assert config.host == "0.0.0.0"+ assert config.port == 1944+ assert config.workers == 2+ assert config.auth_mode == "trusted"+ assert config.with_bot is True+ assert config.bot_api_url == "http://localhost:19999"+ assert config.telemetry.prometheus.enabled is True+ assert config.encryption_enabled is True