ds2api / agy2api /config.py
luckfun233
feat(agy): 内嵌 agy2api,接入 Gemini 模型与独立 AGY 面板
b0074f5
Raw History Blame Contribute Delete
24.8 kB
"""
Configuration constants for the Geminicli2api proxy server.
Centralizes all configuration to avoid duplication across modules.
- 启动时加载一次配置到内存
- 修改配置时调用 reload_config() 重新从数据库加载
"""
import ipaddress
import json
import os
import re
from typing import Any, Optional
from log import log
# 全局配置缓存
_config_cache: dict[str, Any] = {}
_config_initialized = False
# Client Configuration
# 需要自动封禁的错误码 (默认值,可通过环境变量或配置覆盖)
AUTO_BAN_ERROR_CODES = [403]
# ====================== 环境变量映射表 ======================
# 统一维护环境变量名和配置键名的映射关系
# 格式: "环境变量名": "配置键名"
ENV_MAPPINGS = {
"CREDENTIALS_DIR": "credentials_dir",
"PROXY": "proxy",
"OAUTH_PROXY_URL": "oauth_proxy_url",
"GOOGLEAPIS_PROXY_URL": "googleapis_proxy_url",
"ANTIGRAVITY_API_URL": "antigravity_api_url",
"AUTO_BAN": "auto_ban_enabled",
"AUTO_BAN_ERROR_CODES": "auto_ban_error_codes",
"RETRY_429_MAX_RETRIES": "retry_429_max_retries",
"RETRY_429_ENABLED": "retry_429_enabled",
"RETRY_429_INTERVAL": "retry_429_interval",
"ANTI_TRUNCATION_MAX_ATTEMPTS": "anti_truncation_max_attempts",
"RETURN_THOUGHTS_TO_FRONTEND": "return_thoughts_to_frontend",
"SENSITIVE_WORDS": "sensitive_words",
"SENSITIVE_WORDS_ENABLED": "sensitive_words_enabled",
"IP_WHITELIST": "ip_whitelist",
"IP_WHITELIST_ENABLED": "ip_whitelist_enabled",
"MODEL_REWRITE_ENABLED": "model_rewrite_enabled",
"MODEL_REWRITE_RULES": "model_rewrite_rules",
"USAGE_LOG_ENABLED": "usage_log_enabled",
"REQUEST_LOG_ENABLED": "request_log_enabled",
"REQUEST_LOG_ERROR_CODES": "request_log_error_codes",
"CREDENTIAL_SELECT_MODE": "credential_select_mode",
"HOST": "host",
"PORT": "port",
"API_PASSWORD": "api_password",
"PANEL_PASSWORD": "panel_password",
}
# ====================== 配置系统 ======================
async def init_config():
"""初始化配置缓存(启动时调用一次)"""
global _config_cache, _config_initialized
if _config_initialized:
return
try:
from src.storage.database import get_database
database = await get_database()
_config_cache = await database.get_all_config()
_config_initialized = True
except Exception:
# 初始化失败时使用空缓存
_config_cache = {}
_config_initialized = True
async def reload_config():
"""重新加载配置(修改配置后调用)"""
global _config_cache, _config_initialized
try:
from src.storage.database import get_database
database = await get_database()
# 重新加载数据库配置缓存
await database.reload_config_cache()
# 重新加载配置缓存
_config_cache = await database.get_all_config()
_config_initialized = True
except Exception:
pass
def _get_cached_config(key: str, default: Any = None) -> Any:
"""从内存缓存获取配置(同步)"""
return _config_cache.get(key, default)
async def get_config_value(key: str, default: Any = None, env_var: Optional[str] = None) -> Any:
"""Get configuration value with priority: ENV > Storage > default."""
# 确保配置已初始化
if not _config_initialized:
await init_config()
# Priority 1: Environment variable
if env_var and os.getenv(env_var):
return os.getenv(env_var)
# Priority 2: Memory cache
value = _get_cached_config(key)
if value is not None:
return value
return default
# Configuration getters - all async
async def get_proxy_config():
"""Get proxy configuration, validating the URL format.
Supports http://, https://, socks5://, socks5h:// schemes, all with
optional embedded credentials (user:pass@host:port).
"""
proxy_url = await get_config_value("proxy", env_var="PROXY")
if not proxy_url:
return None
proxy_url = proxy_url.strip()
scheme = proxy_url.split("://", 1)[0].lower()
if scheme not in ("http", "https", "socks5", "socks5h"):
log.warning(
f"不支持的代理协议: {scheme}://(支持 http/https/socks5/socks5h),已忽略代理"
)
return None
return proxy_url
async def get_auto_ban_enabled() -> bool:
"""Get auto ban enabled setting."""
env_value = os.getenv("AUTO_BAN")
if env_value:
return env_value.lower() in ("true", "1", "yes", "on")
return bool(await get_config_value("auto_ban_enabled", False))
async def get_auto_ban_error_codes() -> list:
"""
Get auto ban error codes.
Environment variable: AUTO_BAN_ERROR_CODES (comma-separated, e.g., "400,403")
Database config key: auto_ban_error_codes
Default: [400, 403]
"""
env_value = os.getenv("AUTO_BAN_ERROR_CODES")
if env_value:
try:
return [int(code.strip()) for code in env_value.split(",") if code.strip()]
except ValueError:
pass
codes = await get_config_value("auto_ban_error_codes")
if codes and isinstance(codes, list):
return codes
return AUTO_BAN_ERROR_CODES
async def get_retry_429_max_retries() -> int:
"""Get max retries for 429 errors."""
env_value = os.getenv("RETRY_429_MAX_RETRIES")
if env_value:
try:
return int(env_value)
except ValueError:
pass
return int(await get_config_value("retry_429_max_retries", 5))
async def get_retry_429_enabled() -> bool:
"""Get 429 retry enabled setting."""
env_value = os.getenv("RETRY_429_ENABLED")
if env_value:
return env_value.lower() in ("true", "1", "yes", "on")
return bool(await get_config_value("retry_429_enabled", True))
async def get_retry_429_interval() -> float:
"""Get 429 retry interval in seconds."""
env_value = os.getenv("RETRY_429_INTERVAL")
if env_value:
try:
return float(env_value)
except ValueError:
pass
return float(await get_config_value("retry_429_interval", 1))
async def get_anti_truncation_max_attempts() -> int:
"""
Get maximum attempts for anti-truncation continuation.
Environment variable: ANTI_TRUNCATION_MAX_ATTEMPTS
Database config key: anti_truncation_max_attempts
Default: 3
"""
env_value = os.getenv("ANTI_TRUNCATION_MAX_ATTEMPTS")
if env_value:
try:
return int(env_value)
except ValueError:
pass
return int(await get_config_value("anti_truncation_max_attempts", 3))
# Server Configuration
async def get_server_host() -> str:
"""
Get server host setting.
Environment variable: HOST
Database config key: host
Default: 0.0.0.0
"""
return str(await get_config_value("host", "0.0.0.0", "HOST"))
async def get_server_port() -> int:
"""
Get server port setting.
Environment variable: PORT
Database config key: port
Default: 7861
"""
env_value = os.getenv("PORT")
if env_value:
try:
return int(env_value)
except ValueError:
pass
return int(await get_config_value("port", 7861))
async def get_api_password() -> str:
"""
Get API password setting for chat endpoints.
Environment variable: API_PASSWORD
Database config key: api_password
Default: pwd
"""
return str(await get_config_value("api_password", "pwd", "API_PASSWORD"))
async def get_panel_password() -> str:
"""
Get panel password setting for web interface.
Environment variable: PANEL_PASSWORD
Database config key: panel_password
Default: pwd
"""
return str(await get_config_value("panel_password", "pwd", "PANEL_PASSWORD"))
async def get_credentials_dir() -> str:
"""
Get credentials directory setting.
Environment variable: CREDENTIALS_DIR
Database config key: credentials_dir
Default: ./creds
"""
return str(await get_config_value("credentials_dir", "./creds", "CREDENTIALS_DIR"))
async def get_return_thoughts_to_frontend() -> bool:
"""
Get return thoughts to frontend setting.
控制是否将思维链返回到前端。
启用后,思维链会在响应中返回;禁用后,思维链会在响应中被过滤掉。
Environment variable: RETURN_THOUGHTS_TO_FRONTEND
Database config key: return_thoughts_to_frontend
Default: True
"""
env_value = os.getenv("RETURN_THOUGHTS_TO_FRONTEND")
if env_value:
return env_value.lower() in ("true", "1", "yes", "on")
return bool(await get_config_value("return_thoughts_to_frontend", True))
# ====================== 敏感词过滤 ======================
# 敏感词正则编译缓存: (原始词表指纹, 编译后的 pattern 列表)
_sensitive_words_cache: dict = {"fingerprint": None, "patterns": []}
async def get_sensitive_words_enabled() -> bool:
"""
敏感词过滤开关。
Environment variable: SENSITIVE_WORDS_ENABLED
Database config key: sensitive_words_enabled
Default: False
"""
env_value = os.getenv("SENSITIVE_WORDS_ENABLED")
if env_value:
return env_value.lower() in ("true", "1", "yes", "on")
return bool(await get_config_value("sensitive_words_enabled", False))
async def get_sensitive_words() -> list:
"""
敏感词列表(支持正则),每行一个;空列表表示不过滤。
Environment variable: SENSITIVE_WORDS (逗号或换行分隔)
Database config key: sensitive_words
Default: []
"""
env_value = os.getenv("SENSITIVE_WORDS")
if env_value:
words = [w.strip() for w in re.split(r"[,\n]", env_value) if w.strip()]
return words
value = await get_config_value("sensitive_words")
if isinstance(value, list):
return [str(w) for w in value if str(w).strip()]
if isinstance(value, str) and value.strip():
return [w.strip() for w in re.split(r"[,\n]", value) if w.strip()]
return []
def compile_sensitive_words(words: list):
"""
编译敏感词为大小写不敏感的正则列表(带缓存)。
每个词按字面量转义后编译(用户输入的是词/短语而非正则语法),
触发后整词替换为空。支持中文(re.UNICODE 默认开启)。
Returns:
编译后的 Pattern 列表;无效条目跳过并告警。
"""
fingerprint = tuple(words)
if _sensitive_words_cache["fingerprint"] == fingerprint:
return _sensitive_words_cache["patterns"]
patterns = []
for word in words:
word = str(word).strip()
if not word:
continue
try:
patterns.append(re.compile(re.escape(word), re.IGNORECASE | re.UNICODE))
except re.error as e:
log.warning(f"敏感词编译失败,已跳过: {word!r} ({e})")
_sensitive_words_cache["fingerprint"] = fingerprint
_sensitive_words_cache["patterns"] = patterns
return patterns
def apply_sensitive_word_filter(text: str, patterns) -> str:
"""将文本中命中的敏感词(大小写不敏感)替换为空"""
if not text or not patterns:
return text
for pattern in patterns:
text = pattern.sub("", text)
return text
async def get_sensitive_word_filter():
"""
获取生效的敏感词过滤条件(供请求处理管道调用)。
Returns:
(enabled, patterns);未启用时 patterns 为空列表。
"""
if not await get_sensitive_words_enabled():
return False, []
words = await get_sensitive_words()
if not words:
return False, []
return True, compile_sensitive_words(words)
# ====================== IP 白名单 ======================
# IP 白名单规则缓存: (原始条目指纹, 解析结果 (rules, invalid))
_ip_whitelist_cache: dict = {"fingerprint": None, "result": ([], [])}
def parse_ip_whitelist_line(line: str):
"""
解析单条白名单条目为 (lo, hi, version) 网络对象;无效时抛出 ValueError。
支持格式(IPv4 / IPv6):
- 单个 IP: 192.168.1.1 / ::1
- CIDR 网段: 192.168.1.0/24 / 2001:db8::/32
- IP 起止范围(- 或 ~ 分隔): 192.168.1.1-192.168.1.100 / ::1-::10
"""
line = str(line).strip()
if not line:
raise ValueError("空条目")
for sep in ("~", "-"):
if sep in line:
start_str, _, end_str = line.partition(sep)
if start_str.strip() and end_str.strip():
start = ipaddress.ip_address(start_str.strip())
end = ipaddress.ip_address(end_str.strip())
if start.version != end.version:
raise ValueError(f"起止 IP 版本不一致: {line}")
if int(start) > int(end):
start, end = end, start
return start, end, start.version
if "/" in line:
net = ipaddress.ip_network(line, strict=False)
return net.network_address, net.broadcast_address, net.version
addr = ipaddress.ip_address(line)
return addr, addr, addr.version
def compile_ip_whitelist(entries: list):
"""
解析白名单条目列表为规则列表(带缓存)。
Returns:
(rules, invalid)——rules 为 [(lo, hi, version), ...],invalid 为解析失败的原始条目。
"""
fingerprint = tuple(str(e) for e in entries)
if _ip_whitelist_cache["fingerprint"] == fingerprint:
return _ip_whitelist_cache["result"]
rules = []
invalid = []
for entry in entries:
entry = str(entry).strip()
if not entry:
continue
try:
rules.append(parse_ip_whitelist_line(entry))
except ValueError:
invalid.append(entry)
result = (rules, invalid)
_ip_whitelist_cache["fingerprint"] = fingerprint
_ip_whitelist_cache["result"] = result
return result
def ip_in_whitelist(client_ip: str, rules: list) -> bool:
"""判断客户端 IP 是否命中白名单规则(IPv4/IPv6 均支持)"""
if not client_ip:
return False
try:
addr = ipaddress.ip_address(client_ip)
except ValueError:
return False
return any(lo.version == addr.version and lo <= addr <= hi for lo, hi, _ in rules)
async def get_ip_whitelist_enabled() -> bool:
"""
IP 白名单开关。
Environment variable: IP_WHITELIST_ENABLED
Database config key: ip_whitelist_enabled
Default: False
"""
env_value = os.getenv("IP_WHITELIST_ENABLED")
if env_value:
return env_value.lower() in ("true", "1", "yes", "on")
return bool(await get_config_value("ip_whitelist_enabled", False))
async def get_ip_whitelist() -> list:
"""
IP 白名单列表,每行一条;空列表表示不限制。
支持单个 IP、CIDR 网段、起止范围(- 或 ~ 分隔),IPv4/IPv6 均可。
仅在开关开启时生效,命中白名单以外 IP 的所有请求(面板 + API)将直接返回 403。
Environment variable: IP_WHITELIST (逗号或换行分隔)
Database config key: ip_whitelist
Default: []
"""
env_value = os.getenv("IP_WHITELIST")
if env_value is not None and env_value.strip():
return [e.strip() for e in re.split(r"[,\n]", env_value) if e.strip()]
value = await get_config_value("ip_whitelist")
if isinstance(value, list):
return [str(e).strip() for e in value if str(e).strip()]
if isinstance(value, str) and value.strip():
return [e.strip() for e in re.split(r"[,\n]", value) if e.strip()]
return []
async def get_ip_whitelist_rules():
"""
获取生效的 IP 白名单规则(供请求拦截中间件调用)。
Returns:
(enabled, rules);开关关闭或白名单为空时不启用限制。
"""
if not await get_ip_whitelist_enabled():
return False, []
entries = await get_ip_whitelist()
if not entries:
return False, []
rules, invalid = compile_ip_whitelist(entries)
if invalid:
log.warning(f"IP 白名单中存在无效条目(已跳过): {invalid}")
return bool(rules), rules
# ====================== 模型名复写 ======================
# 模型名复写规则缓存: (指纹, (编译后的规则列表, 无效规则列表))
_model_rewrite_cache: dict = {"fingerprint": None, "result": ([], [])}
async def get_model_rewrite_enabled() -> bool:
"""
模型名复写开关。
Environment variable: MODEL_REWRITE_ENABLED
Database config key: model_rewrite_enabled
Default: False
"""
env_value = os.getenv("MODEL_REWRITE_ENABLED")
if env_value:
return env_value.lower() in ("true", "1", "yes", "on")
return bool(await get_config_value("model_rewrite_enabled", False))
async def get_model_rewrite_rules_config() -> list:
"""
模型名复写规则列表,每条为 [pattern, replacement]。
pattern 支持正则(对模型名做全匹配搜索,命中任意一处即替换),
replacement 中可使用正则反向引用(如 \\1)。
Environment variable: MODEL_REWRITE_RULES (JSON 数组,如 [["gpt-4","gemini-2.5-pro"]];也支持 "pat->rep" 逗号分隔的简化格式)
Database config key: model_rewrite_rules
Default: []
"""
env_value = os.getenv("MODEL_REWRITE_RULES")
if env_value is not None and env_value.strip():
parsed = _parse_model_rewrite_rules_value(env_value)
if parsed is not None:
return parsed
value = await get_config_value("model_rewrite_rules")
return _parse_model_rewrite_rules_value(value) or []
def _parse_model_rewrite_rules_value(value: Any) -> Optional[list]:
"""将配置值解析为 [[pattern, replacement], ...];无法解析时返回 None"""
if isinstance(value, list):
rules = []
for item in value:
if isinstance(item, (list, tuple)) and len(item) == 2 and all(isinstance(x, str) for x in item):
rules.append([item[0], item[1]])
elif isinstance(item, dict) and isinstance(item.get("pattern"), str) and isinstance(item.get("replacement"), str):
rules.append([item["pattern"], item["replacement"]])
return rules
if isinstance(value, str) and value.strip():
# 优先尝试 JSON 数组格式(环境变量推荐格式)
if value.strip().startswith("["):
try:
parsed = json.loads(value)
if isinstance(parsed, list):
inner = _parse_model_rewrite_rules_value(parsed)
if inner is not None:
return inner
except (json.JSONDecodeError, ValueError):
pass
# 兼容 "pat->rep,pat->rep" 简化格式
rules = []
for pair in value.split(","):
pair = pair.strip()
if "->" in pair:
pat, _, rep = pair.partition("->")
rules.append([pat.strip(), rep.strip()])
return rules or None
return None
def compile_model_rewrite_rules(rules: list):
"""
编译复写规则为 (pattern, replacement) 元组列表(带缓存)。
Returns:
(compiled, invalid)——invalid 为编译失败的原始规则。
"""
fingerprint = tuple(tuple(r) for r in rules)
if _model_rewrite_cache["fingerprint"] == fingerprint:
return _model_rewrite_cache["result"]
compiled = []
invalid = []
for rule in rules:
if not (isinstance(rule, (list, tuple)) and len(rule) == 2):
continue
pattern, replacement = rule[0], rule[1]
try:
compiled.append((re.compile(str(pattern)), str(replacement)))
except re.error:
invalid.append(rule)
result = (compiled, invalid)
_model_rewrite_cache["fingerprint"] = fingerprint
_model_rewrite_cache["result"] = result
return result
def rewrite_model_name(model_name: str, compiled_rules: list) -> str:
"""
按规则顺序应用模型名复写(命中第一条即停止)。
使用 re.sub 全字符串搜索替换;replacement 支持 \\1 等反向引用。
"""
for pattern, replacement in compiled_rules:
if pattern.search(model_name):
return pattern.sub(replacement, model_name)
return model_name
async def get_model_rewrite_filter():
"""
获取生效的模型名复写规则(供请求处理管道调用)。
Returns:
(enabled, compiled_rules);未启用时 compiled_rules 为空列表。
"""
if not await get_model_rewrite_enabled():
return False, []
rules = await get_model_rewrite_rules_config()
if not rules:
return False, []
compiled, invalid = compile_model_rewrite_rules(rules)
if invalid:
log.warning(f"模型名复写规则中存在无效正则(已跳过): {invalid}")
return bool(compiled), compiled
# ====================== 请求日志 ======================
async def get_usage_log_enabled() -> bool:
"""
请求日志(usage_log)开关。
Environment variable: USAGE_LOG_ENABLED
Database config key: usage_log_enabled
Default: True
"""
env_value = os.getenv("USAGE_LOG_ENABLED")
if env_value:
return env_value.lower() in ("true", "1", "yes", "on")
return bool(await get_config_value("usage_log_enabled", True))
async def get_request_log_enabled() -> bool:
"""
请求体详细日志开关。
Environment variable: REQUEST_LOG_ENABLED
Database config key: request_log_enabled
Default: False
"""
env_value = os.getenv("REQUEST_LOG_ENABLED")
if env_value:
return env_value.lower() in ("true", "1", "yes", "on")
return bool(await get_config_value("request_log_enabled", False))
async def get_request_log_error_codes() -> list:
"""
请求体详细日志记录的错误码列表(仅命中时写盘)。
Environment variable: REQUEST_LOG_ERROR_CODES (逗号分隔, 如 "400,429")
Database config key: request_log_error_codes
Default: [400]
"""
env_value = os.getenv("REQUEST_LOG_ERROR_CODES")
if env_value:
try:
return [int(code.strip()) for code in env_value.split(",") if code.strip()]
except ValueError:
pass
codes = await get_config_value("request_log_error_codes")
if codes and isinstance(codes, list):
return codes
return [400]
# ====================== 凭证选择模式 ======================
# 合法的凭证选择模式
CREDENTIAL_SELECT_MODES = ("random", "cache", "sticky")
async def get_credential_select_mode() -> str:
"""
凭证选择模式:
- random: 完全随机负载均衡(无亲和)
- cache: 会话缓存匹配(默认)——相同会话内容复用同一凭证,命中上游 prompt cache
- sticky: 凭证粘性——尽量保持同一凭证直到其进入 CD 或被禁用
Environment variable: CREDENTIAL_SELECT_MODE
Database config key: credential_select_mode
Default: cache
"""
value = await get_config_value("credential_select_mode", "cache", "CREDENTIAL_SELECT_MODE")
value = str(value).strip().lower()
if value not in CREDENTIAL_SELECT_MODES:
log.warning(f"无效的凭证选择模式: {value},回落为 cache")
return "cache"
return value
async def get_oauth_proxy_url() -> str:
"""
Get OAuth proxy URL setting.
用于Google OAuth2认证的代理URL。
Environment variable: OAUTH_PROXY_URL
Database config key: oauth_proxy_url
Default: https://oauth2.googleapis.com
"""
return str(
await get_config_value(
"oauth_proxy_url", "https://oauth2.googleapis.com", "OAUTH_PROXY_URL"
)
)
async def get_googleapis_proxy_url() -> str:
"""
Get Google APIs proxy URL setting.
用于Google APIs调用的代理URL。
Environment variable: GOOGLEAPIS_PROXY_URL
Database config key: googleapis_proxy_url
Default: https://www.googleapis.com
"""
return str(
await get_config_value(
"googleapis_proxy_url", "https://www.googleapis.com", "GOOGLEAPIS_PROXY_URL"
)
)
async def get_antigravity_api_url() -> str:
"""
Get Antigravity API URL setting.
用于Google Antigravity API的URL。
Environment variable: ANTIGRAVITY_API_URL
Database config key: antigravity_api_url
Default: https://daily-cloudcode-pa.googleapis.com
"""
return str(
await get_config_value(
"antigravity_api_url",
"https://daily-cloudcode-pa.googleapis.com",
"ANTIGRAVITY_API_URL",
)
)