511 lines
21 KiB
Python
511 lines
21 KiB
Python
"""
|
||
config/settings.py
|
||
配置加载与管理 —— 新增 mcp_skills 在线 MCP Server 配置节
|
||
工具配置通过 settings.tools['tool_name']['key'] 访问
|
||
在线 skill 配置通过 settings.mcp_skills 列表访问
|
||
"""
|
||
|
||
import os
|
||
from dataclasses import dataclass, field
|
||
from pathlib import Path
|
||
from typing import Any
|
||
|
||
try:
|
||
import yaml
|
||
_YAML_AVAILABLE = True
|
||
except ImportError:
|
||
_YAML_AVAILABLE = False
|
||
|
||
|
||
# ════════════════════════════════════════════════════════════════
|
||
# 默认配置（与 config.yaml 结构完全对应）
|
||
# ════════════════════════════════════════════════════════════════
|
||
|
||
_DEFAULTS: dict[str, Any] = {
|
||
"llm": {
|
||
"provider": "openai",
|
||
"model_name": "gpt-4o",
|
||
"api_key": "",
|
||
"api_base_url": "",
|
||
"max_tokens": 4096,
|
||
"temperature": 0.7,
|
||
"timeout": 60,
|
||
"max_retries": 3,
|
||
"function_calling": True,
|
||
"stream": False,
|
||
"model_path": "",
|
||
"ollama_host": "http://localhost:11434",
|
||
},
|
||
"mcp": {
|
||
"server_name": "DemoMCPServer",
|
||
"transport": "stdio",
|
||
"host": "localhost",
|
||
"port": 3000,
|
||
"enabled_tools": [
|
||
"calculator", "web_search", "file_reader",
|
||
"code_executor", "static_analyzer", "ssh_docker",
|
||
],
|
||
},
|
||
"mcp_skills": [],
|
||
"tools": {
|
||
"calculator": {"precision": 10},
|
||
"web_search": {"max_results": 5, "timeout": 10, "api_key": "", "engine": "mock"},
|
||
"file_reader": {"allowed_root": "./workspace", "max_file_size_kb": 512},
|
||
"code_executor": {"timeout": 5, "sandbox": True},
|
||
"static_analyzer": {
|
||
"default_tool": "cppcheck",
|
||
"default_std": "c++17",
|
||
"timeout": 120,
|
||
"jobs": 4,
|
||
"output_format": "summary",
|
||
"max_issues": 500,
|
||
"allowed_roots": [],
|
||
"tool_extra_args": {
|
||
"cppcheck": "--suppress=missingIncludeSystem --suppress=unmatchedSuppression",
|
||
"clang-tidy": "--checks=*,-fuchsia-*,-google-*,-zircon-*",
|
||
"infer": "",
|
||
},
|
||
},
|
||
"ssh_docker": {
|
||
"default_ssh_port": 22,
|
||
"default_username": "root",
|
||
"connect_timeout": 30,
|
||
"cmd_timeout": 120,
|
||
"deploy_timeout": 300,
|
||
"default_restart_policy": "unless-stopped",
|
||
"default_tail_lines": 100,
|
||
"allowed_hosts": [],
|
||
"blocked_images": [],
|
||
"allow_privileged": False,
|
||
"servers": {},
|
||
},
|
||
},
|
||
"memory": {"max_history": 20, "enable_long_term": False, "vector_db_url": ""},
|
||
"logging": {"level": "DEBUG", "enable_file": True, "log_dir": "./logs", "log_file": "agent.log"},
|
||
"agent": {"max_chain_steps": 10, "enable_multi_step": True, "session_timeout": 3600, "fallback_to_rules": True},
|
||
}
|
||
|
||
|
||
# ════════════════════════════════════════════════════════════════
|
||
# 在线 MCP Skill 配置对象
|
||
# ════════════════════════════════════════════════════════════════
|
||
|
||
@dataclass
|
||
class MCPSkillConfig:
|
||
"""
|
||
单个在线 MCP Server 的连接配置
|
||
|
||
访问方式:
|
||
for skill in settings.mcp_skills:
|
||
skill.name
|
||
skill.transport
|
||
skill.url
|
||
skill.headers
|
||
skill.command / skill.args / skill.env # stdio 模式
|
||
skill.timeout
|
||
skill.retry
|
||
skill.include_tools
|
||
skill.exclude_tools
|
||
"""
|
||
name: str # skill 组名称
|
||
enabled: bool = True
|
||
transport: str = "sse" # sse | http | stdio
|
||
url: str = "" # sse / http 模式
|
||
headers: dict[str, str] = field(default_factory=dict)
|
||
command: str = "" # stdio 模式：可执行文件
|
||
args: list[str] = field(default_factory=list)
|
||
env: dict[str, str] = field(default_factory=dict)
|
||
timeout: int = 30
|
||
retry: int = 2
|
||
include_tools: list[str] = field(default_factory=list)
|
||
exclude_tools: list[str] = field(default_factory=list)
|
||
|
||
def __post_init__(self):
|
||
# 从环境变量自动填充 headers 中的空值
|
||
# 规则: headers 中值为空字符串时，尝试读取
|
||
# MCP_{NAME}_{HEADER_KEY} 环境变量
|
||
# 例如: name=everything, header key=Authorization
|
||
# → 环境变量: MCP_EVERYTHING_AUTHORIZATION
|
||
prefix = f"MCP_{self.name.upper().replace('-', '_')}"
|
||
for key, val in self.headers.items():
|
||
if not val:
|
||
env_key = f"{prefix}_{key.upper().replace('-', '_')}"
|
||
if env_val := os.getenv(env_key):
|
||
self.headers[key] = env_val
|
||
|
||
def is_tool_allowed(self, tool_name: str) -> bool:
|
||
"""判断工具是否应被暴露（include/exclude 过滤）"""
|
||
if self.exclude_tools and tool_name in self.exclude_tools:
|
||
return False
|
||
if self.include_tools and tool_name not in self.include_tools:
|
||
return False
|
||
return True
|
||
|
||
def display(self) -> str:
|
||
if self.transport == "stdio":
|
||
conn = f"stdio cmd={self.command} {' '.join(self.args)}"
|
||
else:
|
||
conn = f"{self.transport} url={self.url}"
|
||
return (
|
||
f" MCPSkill[{self.name}] enabled={self.enabled} {conn}\n"
|
||
f" timeout={self.timeout}s retry={self.retry}\n"
|
||
f" include={self.include_tools or '(全部)'} "
|
||
f"exclude={self.exclude_tools or '(无)'}"
|
||
)
|
||
|
||
|
||
# ════════════════════════════════════════════════════════════════
|
||
# ToolsView —— 工具配置字典视图
|
||
# ════════════════════════════════════════════════════════════════
|
||
|
||
class ToolsView:
|
||
"""
|
||
工具配置字典视图，支持:
|
||
settings.tools['web_search']['timeout']
|
||
settings.tools['static_analyzer']['tool_extra_args']['cppcheck']
|
||
'ssh_docker' in settings.tools
|
||
"""
|
||
|
||
def __init__(self, data: dict[str, dict]):
|
||
self._data = data
|
||
|
||
def __getitem__(self, tool_name: str) -> dict[str, Any]:
|
||
if tool_name not in self._data:
|
||
raise KeyError(
|
||
f"工具 '{tool_name}' 未在配置中定义。"
|
||
f"可用工具: {list(self._data.keys())}"
|
||
)
|
||
return self._data[tool_name]
|
||
|
||
def __contains__(self, tool_name: str) -> bool:
|
||
return tool_name in self._data
|
||
|
||
def __repr__(self) -> str:
|
||
return f"ToolsView({list(self._data.keys())})"
|
||
|
||
def get(self, tool_name: str, default: Any = None) -> Any:
|
||
return self._data.get(tool_name, default)
|
||
|
||
def keys(self):
|
||
return self._data.keys()
|
||
|
||
|
||
# ════════════════════════════════════════════════════════════════
|
||
# 其他配置 dataclass
|
||
# ════════════════════════════════════════════════════════════════
|
||
|
||
@dataclass
|
||
class LLMConfig:
|
||
provider: str = "openai"
|
||
model_name: str = "gpt-4o"
|
||
api_key: str = ""
|
||
api_base_url: str = ""
|
||
max_tokens: int = 4096
|
||
temperature: float = 0.7
|
||
timeout: int = 60
|
||
max_retries: int = 3
|
||
function_calling: bool = True
|
||
stream: bool = False
|
||
model_path: str = ""
|
||
ollama_host: str = "http://localhost:11434"
|
||
|
||
def __post_init__(self):
|
||
self.api_key = os.getenv("LLM_API_KEY", self.api_key)
|
||
self.api_base_url = os.getenv("LLM_API_BASE_URL", self.api_base_url)
|
||
self.model_name = os.getenv("LLM_MODEL_NAME", self.model_name)
|
||
|
||
|
||
@dataclass
|
||
class MCPConfig:
|
||
server_name: str = "DemoMCPServer"
|
||
transport: str = "stdio"
|
||
host: str = "localhost"
|
||
port: int = 3000
|
||
enabled_tools: list[str] = field(default_factory=lambda: [
|
||
"calculator", "web_search", "file_reader",
|
||
"code_executor", "static_analyzer", "ssh_docker",
|
||
])
|
||
|
||
|
||
@dataclass
|
||
class MemoryConfig:
|
||
max_history: int = 20
|
||
enable_long_term: bool = False
|
||
vector_db_url: str = ""
|
||
|
||
|
||
@dataclass
|
||
class LoggingConfig:
|
||
level: str = "DEBUG"
|
||
enable_file: bool = True
|
||
log_dir: str = "./logs"
|
||
log_file: str = "agent.log"
|
||
|
||
def __post_init__(self):
|
||
self.level = os.getenv("LOG_LEVEL", self.level).upper()
|
||
|
||
|
||
@dataclass
|
||
class AgentConfig:
|
||
max_chain_steps: int = 10
|
||
enable_multi_step: bool = True
|
||
session_timeout: int = 3600
|
||
fallback_to_rules: bool = True
|
||
|
||
|
||
# ════════════════════════════════════════════════════════════════
|
||
# 顶层 AppConfig
|
||
# ════════════════════════════════════════════════════════════════
|
||
|
||
class AppConfig:
|
||
"""
|
||
全局配置单例
|
||
|
||
访问方式:
|
||
settings.llm.model_name
|
||
settings.mcp.enabled_tools
|
||
settings.mcp_skills # list[MCPSkillConfig]
|
||
settings.mcp_skills[0].name
|
||
settings.mcp_skills[0].url
|
||
settings.tools['web_search']['timeout']
|
||
settings.tools['ssh_docker']['servers']['prod']['host']
|
||
settings.memory.max_history
|
||
settings.agent.fallback_to_rules
|
||
settings.logging.level
|
||
"""
|
||
|
||
def __init__(
|
||
self,
|
||
llm: LLMConfig,
|
||
mcp: MCPConfig,
|
||
mcp_skills: list[MCPSkillConfig],
|
||
tools: ToolsView,
|
||
memory: MemoryConfig,
|
||
logging: LoggingConfig,
|
||
agent: AgentConfig,
|
||
skills_directory: str = "./skills"
|
||
):
|
||
self.llm = llm
|
||
self.mcp = mcp
|
||
self.mcp_skills = mcp_skills # 在线 MCP Skill 列表
|
||
self.tools = tools
|
||
self.memory = memory
|
||
self.logging = logging
|
||
self.agent = agent
|
||
self.skills_directory = skills_directory
|
||
|
||
@property
|
||
def enabled_mcp_skills(self) -> list[MCPSkillConfig]:
|
||
"""返回所有 enabled=true 的在线 MCP Skill"""
|
||
return [s for s in self.mcp_skills if s.enabled]
|
||
|
||
def display(self) -> str:
|
||
sa = self.tools['static_analyzer']
|
||
ssh = self.tools['ssh_docker']
|
||
ws = self.tools['web_search']
|
||
lines = [
|
||
"─" * 64,
|
||
" 📋 当前配置",
|
||
"─" * 64,
|
||
f" [LLM] provider = {self.llm.provider}",
|
||
f" [LLM] model_name = {self.llm.model_name}",
|
||
f" [LLM] api_key = {'***' + self.llm.api_key[-4:] if len(self.llm.api_key) > 4 else '(未设置)'}",
|
||
f" [LLM] temperature = {self.llm.temperature}",
|
||
f" [MCP] enabled_tools = {self.mcp.enabled_tools}",
|
||
"",
|
||
f" [MCP_SKILLS] 在线 Skill 数量: {len(self.mcp_skills)} "
|
||
f"(已启用: {len(self.enabled_mcp_skills)})",
|
||
]
|
||
for skill in self.mcp_skills:
|
||
icon = "✅" if skill.enabled else "⏸ "
|
||
lines.append(f" {icon} {skill.display()}")
|
||
for tool_name in self.tools.keys():
|
||
tool = self.tools[tool_name]
|
||
for config, value in tool.items():
|
||
lines += [
|
||
f" [TOOL][{tool_name}] {config}\t\t= {value}"
|
||
]
|
||
lines += [
|
||
"",
|
||
f" [MEM] max_history = {self.memory.max_history}",
|
||
f" [AGT] max_chain_steps = {self.agent.max_chain_steps}",
|
||
f" [LOG] level = {self.logging.level}",
|
||
"─" * 64,
|
||
]
|
||
return "\n".join(lines)
|
||
|
||
|
||
# ════════════════════════════════════════════════════════════════
|
||
# 配置加载器
|
||
# ════════════════════════════════════════════════════════════════
|
||
|
||
class ConfigLoader:
|
||
_SEARCH_PATHS = [
|
||
Path(os.getenv("AGENT_CONFIG_PATH", "__none__")),
|
||
Path("config") / "config.yaml",
|
||
Path("config.yaml"),
|
||
]
|
||
|
||
@classmethod
|
||
def load(cls) -> AppConfig:
|
||
raw = cls._read_yaml()
|
||
return cls._build(raw if raw is not None else {})
|
||
|
||
@classmethod
|
||
def _read_yaml(cls) -> dict[str, Any] | None:
|
||
if not _YAML_AVAILABLE:
|
||
print("⚠️ PyYAML 未安装（pip install pyyaml），使用默认配置")
|
||
return None
|
||
for path in cls._SEARCH_PATHS:
|
||
if path and path.exists() and path.suffix in (".yaml", ".yml"):
|
||
with open(path, encoding="utf-8") as f:
|
||
data = yaml.safe_load(f)
|
||
print(f"✅ 已加载配置文件: {path.resolve()}")
|
||
return data or {}
|
||
print("ℹ️ 未找到配置文件，使用默认配置")
|
||
return None
|
||
|
||
@classmethod
|
||
def _build(cls, raw: dict[str, Any]) -> AppConfig:
|
||
return AppConfig(
|
||
llm=cls._build_llm(raw.get("llm", {})),
|
||
mcp=cls._build_mcp(raw.get("mcp", {})),
|
||
mcp_skills=cls._build_mcp_skills(raw.get("mcp_skills", [])),
|
||
tools=cls._build_tools(raw.get("tools", {})),
|
||
memory=cls._build_memory(raw.get("memory", {})),
|
||
logging=cls._build_logging(raw.get("logging", {})),
|
||
agent=cls._build_agent(raw.get("agent", {})),
|
||
skills_directory=raw.get("skills_directory", "")
|
||
)
|
||
|
||
# ── LLM ───────────────────────────────────────────────────
|
||
|
||
@staticmethod
|
||
def _build_llm(d: dict) -> LLMConfig:
|
||
df = _DEFAULTS["llm"]
|
||
return LLMConfig(
|
||
provider=d.get("provider", df["provider"]),
|
||
model_name=d.get("model_name", df["model_name"]),
|
||
api_key=d.get("api_key", df["api_key"]),
|
||
api_base_url=d.get("api_base_url", df["api_base_url"]),
|
||
max_tokens=int(d.get("max_tokens", df["max_tokens"])),
|
||
temperature=float(d.get("temperature", df["temperature"])),
|
||
timeout=int(d.get("timeout", df["timeout"])),
|
||
max_retries=int(d.get("max_retries", df["max_retries"])),
|
||
function_calling=bool(d.get("function_calling", df["function_calling"])),
|
||
stream=bool(d.get("stream", df["stream"])),
|
||
model_path=d.get("model_path", df["model_path"]),
|
||
ollama_host=d.get("ollama_host", df["ollama_host"]),
|
||
)
|
||
|
||
# ── MCP ───────────────────────────────────────────────────
|
||
|
||
@staticmethod
|
||
def _build_mcp(d: dict) -> MCPConfig:
|
||
df = _DEFAULTS["mcp"]
|
||
return MCPConfig(
|
||
server_name=d.get("server_name", df["server_name"]),
|
||
transport=d.get("transport", df["transport"]),
|
||
host=d.get("host", df["host"]),
|
||
port=int(d.get("port", df["port"])),
|
||
enabled_tools=d.get("enabled_tools", df["enabled_tools"]),
|
||
)
|
||
|
||
# ── MCP Skills（在线 MCP Server 列表）────────────────────
|
||
|
||
@staticmethod
|
||
def _build_mcp_skills(raw_list: list) -> list[MCPSkillConfig]:
|
||
skills = []
|
||
if not isinstance(raw_list, list):
|
||
return skills
|
||
for item in raw_list:
|
||
if not isinstance(item, dict):
|
||
continue
|
||
name = item.get("name", "")
|
||
if not name:
|
||
continue
|
||
skills.append(MCPSkillConfig(
|
||
name=name,
|
||
enabled=bool(item.get("enabled", True)),
|
||
transport=item.get("transport", "sse"),
|
||
url=item.get("url", ""),
|
||
headers=dict(item.get("headers", {})),
|
||
command=item.get("command", ""),
|
||
args=list(item.get("args", [])),
|
||
env=dict(item.get("env", {})),
|
||
timeout=int(item.get("timeout", 30)),
|
||
retry=int(item.get("retry", 2)),
|
||
include_tools=list(item.get("include_tools", [])),
|
||
exclude_tools=list(item.get("exclude_tools", [])),
|
||
))
|
||
return skills
|
||
|
||
# ── Tools（纯字典，深度合并）──────────────────────────────
|
||
|
||
@classmethod
|
||
def _build_tools(cls, d: dict) -> ToolsView:
|
||
df = _DEFAULTS["tools"]
|
||
merged: dict[str, dict] = {}
|
||
for tool_name, tool_defaults in df.items():
|
||
yaml_tool = d.get(tool_name, {})
|
||
merged[tool_name] = cls._deep_merge(tool_defaults, yaml_tool)
|
||
for tool_name, tool_cfg in d.items():
|
||
if tool_name not in merged:
|
||
merged[tool_name] = tool_cfg if isinstance(tool_cfg, dict) else {}
|
||
cls._apply_env_overrides(merged)
|
||
return ToolsView(merged)
|
||
|
||
@staticmethod
|
||
def _deep_merge(base: dict, override: dict) -> dict:
|
||
result = dict(base)
|
||
for key, val in override.items():
|
||
if key in result and isinstance(result[key], dict) and isinstance(val, dict):
|
||
result[key] = ConfigLoader._deep_merge(result[key], val)
|
||
else:
|
||
result[key] = val
|
||
return result
|
||
|
||
@staticmethod
|
||
def _apply_env_overrides(tools: dict[str, dict]) -> None:
|
||
if api_key := os.getenv("SEARCH_API_KEY"):
|
||
tools["web_search"]["api_key"] = api_key
|
||
for server_name, srv in tools.get("ssh_docker", {}).get("servers", {}).items():
|
||
if isinstance(srv, dict) and not srv.get("password"):
|
||
env_key = f"SSH_{server_name.upper()}_PASSWORD"
|
||
if pw := os.getenv(env_key):
|
||
srv["password"] = pw
|
||
|
||
# ── Memory / Logging / Agent ──────────────────────────────
|
||
|
||
@staticmethod
|
||
def _build_memory(d: dict) -> MemoryConfig:
|
||
df = _DEFAULTS["memory"]
|
||
return MemoryConfig(
|
||
max_history=int(d.get("max_history", df["max_history"])),
|
||
enable_long_term=bool(d.get("enable_long_term",df["enable_long_term"])),
|
||
vector_db_url=d.get("vector_db_url", df["vector_db_url"]),
|
||
)
|
||
|
||
@staticmethod
|
||
def _build_logging(d: dict) -> LoggingConfig:
|
||
df = _DEFAULTS["logging"]
|
||
return LoggingConfig(
|
||
level=d.get("level", df["level"]),
|
||
enable_file=bool(d.get("enable_file", df["enable_file"])),
|
||
log_dir=d.get("log_dir", df["log_dir"]),
|
||
log_file=d.get("log_file", df["log_file"]),
|
||
)
|
||
|
||
@staticmethod
|
||
def _build_agent(d: dict) -> AgentConfig:
|
||
df = _DEFAULTS["agent"]
|
||
return AgentConfig(
|
||
max_chain_steps=int(d.get("max_chain_steps", df["max_chain_steps"])),
|
||
enable_multi_step=bool(d.get("enable_multi_step", df["enable_multi_step"])),
|
||
session_timeout=int(d.get("session_timeout", df["session_timeout"])),
|
||
fallback_to_rules=bool(d.get("fallback_to_rules", df["fallback_to_rules"])),
|
||
)
|
||
|
||
|
||
# ── 全局单例 ──────────────────────────────────────────────────
|
||
settings: AppConfig = ConfigLoader.load() |