489 lines
25 KiB
Python
489 lines
25 KiB
Python
"""系统级接口:健康检查、平台元数据、模型注册表(图1 模块③的配置面)。"""
|
||
from __future__ import annotations
|
||
|
||
import json
|
||
|
||
from fastapi import APIRouter, Depends, HTTPException
|
||
from sqlalchemy import func, or_, select
|
||
from sqlalchemy.orm import Session
|
||
|
||
from app import schemas
|
||
from app.api import deps
|
||
from app.config import settings
|
||
from app.constants import (ASPECT_RATIOS, RESOLUTIONS, AssetKind, CameraAngle, CameraMovement,
|
||
ProjectStatus, ShotSize, ShotStatus, TaskKind, TaskStatus, Transition)
|
||
from app.api.auth import require_admin
|
||
from app.db import get_db, open_sessions, pool_status, session_trace_enabled
|
||
from app.models import Asset, GenerationRecord, ModelSpec, PlatformMedia, Task, User
|
||
from app.providers import comfy_common, registry as model_registry
|
||
from app.services import auth as auth_service
|
||
from app.services import capacity, daemon, events, execution, ffmpeg as ff, status
|
||
from app.services import secrets
|
||
|
||
router = APIRouter(tags=["system"])
|
||
|
||
MODEL_MEDIA_TYPES = [
|
||
{"value": "llm", "label": "大模型", "icon": "✦",
|
||
"description": "文本推理与提示词补全(OpenAI 兼容接口);图像生成请使用独立图像模型"},
|
||
{"value": "video", "label": "视频模型", "icon": "▷",
|
||
"description": "文生视频、图生视频、首尾帧与参考图生成"},
|
||
{"value": "image", "label": "图像模型", "icon": "▧",
|
||
"description": "定妆图、三视图、服装、表情与场景图"},
|
||
{"value": "tts", "label": "声音模型", "icon": "◉",
|
||
"description": "台词配音、音色样本与多语言声线"},
|
||
]
|
||
|
||
MODEL_ADAPTERS = {
|
||
"llm": ["mock_llm", "http_llm"],
|
||
"video": ["mock", "http", "comfyui"],
|
||
"image": ["mock_image", "http_image", "comfyui_image"],
|
||
"tts": ["mock", "http", "macos_say", "comfyui_tts"],
|
||
}
|
||
|
||
|
||
def _fault_injected(db: Session) -> list[dict]:
|
||
"""列出仍带着 failure_rate 的模型:故障注入是临时态,泄漏出来必须一眼可见。"""
|
||
rows = db.scalars(select(ModelSpec)).all()
|
||
out = []
|
||
for spec in rows:
|
||
rate = float((spec.config_json or {}).get("failure_rate") or 0.0)
|
||
if rate > 0:
|
||
out.append({"id": spec.id, "provider": spec.provider, "model": spec.model,
|
||
"media_type": spec.media_type, "enabled": bool(spec.enabled),
|
||
"failure_rate": round(rate, 4)})
|
||
return out
|
||
|
||
|
||
@router.get("/health")
|
||
def health(db: Session = Depends(get_db)):
|
||
models = db.query(ModelSpec).filter(ModelSpec.enabled.is_(True)).count()
|
||
return {"status": "ok", "app": settings.app_name, "executor": execution.backend_name(),
|
||
"ffmpeg": ff.available(), "ffmpeg_capabilities": ff.capabilities(),
|
||
"database": db.bind.dialect.name if db.bind else "unknown",
|
||
# 连接池现状放在健康检查里:曾经出现过「会话把 5+10 条连接占满,
|
||
# 任务排队 30 秒超时被误判失败」,光看任务状态完全看不出根因。
|
||
"database_pool": pool_status(),
|
||
"model_specs": models, "daemon": daemon.snapshot(),
|
||
# 部署排障最常用的两个开关,直接进健康检查,省得登录服务器翻 .env:
|
||
# auth_enabled=关 意味着任何人裸奔可写;frontend=off 意味着这台只出 API。
|
||
"auth_enabled": bool(settings.auth_enabled),
|
||
"frontend": (str(dist) if (dist := settings.frontend_dist()) else "api-only"),
|
||
"fault_injection": _fault_injected(db)}
|
||
|
||
|
||
@router.get("/api/system/db-debug")
|
||
def db_debug(db: Session = Depends(get_db), _: User = Depends(require_admin)) -> dict:
|
||
"""谁借着数据库会话不还:连接池告急时先看这里。
|
||
|
||
需要以 ``NEX_DB_DEBUG_SESSIONS=1`` 启动才有调用栈;否则只回池子计数。
|
||
"""
|
||
return {"trace_enabled": session_trace_enabled(), "pool": pool_status(),
|
||
"open_sessions": open_sessions(limit=30)}
|
||
|
||
|
||
@router.get("/api/meta")
|
||
def meta(db: Session = Depends(get_db)):
|
||
"""前端下拉框/流程条所需的全部枚举与运行时能力。"""
|
||
return {
|
||
"app": settings.app_name,
|
||
"executor": execution.backend_name(),
|
||
"ffmpeg_available": ff.available(),
|
||
"daemon": daemon.snapshot(),
|
||
"presets": list(ff.EXPORT_PRESETS.keys()),
|
||
"pipeline_stages": status.PIPELINE_STAGES,
|
||
"shot_statuses": ShotStatus.ALL,
|
||
"task_kinds": TaskKind.ALL,
|
||
"task_statuses": TaskStatus.ALL,
|
||
"project_statuses": ProjectStatus.ALL,
|
||
"options": {
|
||
"shot_size": [{"value": k, "label": v} for k, v in ShotSize.LABELS.items()],
|
||
"camera_movement": [{"value": k, "label": v} for k, v in CameraMovement.LABELS.items()],
|
||
"camera_angle": [{"value": k, "label": v} for k, v in CameraAngle.LABELS.items()],
|
||
"transition": [{"value": k, "label": v} for k, v in Transition.LABELS.items()],
|
||
"resolution": [{"value": k, "label": k, "canvas": list(v)} for k, v in RESOLUTIONS.items()],
|
||
"aspect_ratio": [{"value": k, "label": k} for k in ASPECT_RATIOS],
|
||
"mode": [{"value": "t2v", "label": "文生视频"}, {"value": "i2v", "label": "图生视频(关键帧)"},
|
||
{"value": "fl", "label": "首尾帧"}],
|
||
"asset_kinds": [{"value": k, "label": v} for k, v in AssetKind.LABELS.items()],
|
||
"asset_slots": {k: sorted(v) for k, v in deps.OWNER_KINDS.items()},
|
||
},
|
||
}
|
||
|
||
|
||
def _usage_index(db: Session) -> dict[str, dict]:
|
||
"""模型调用量(MC-2):模型卡上只有「启用 / 可达」,看不出这条能力有没有真的在跑活。
|
||
|
||
两个口径合并:
|
||
* 生成台账 GenerationRecord —— 正式出片/配音/关键帧调用(次数、耗时、成本);
|
||
* 素材表 metadata_json —— 由该模型产出的素材个数(含平台母版,带 provider/model 留痕)。
|
||
"""
|
||
usage: dict[str, dict] = {}
|
||
|
||
def bucket(provider: str, model: str) -> dict:
|
||
return usage.setdefault(f"{provider}|{model}", {
|
||
"calls": 0, "seconds": 0.0, "cost": 0.0, "assets": 0, "last_used": None,
|
||
})
|
||
|
||
provider_of = func.json_extract(Asset.metadata_json, "$.provider")
|
||
model_of = func.json_extract(Asset.metadata_json, "$.model")
|
||
for provider, model, count in db.execute(
|
||
select(provider_of, model_of, func.count(Asset.id))
|
||
.where(provider_of.isnot(None), provider_of != "")
|
||
.group_by(provider_of, model_of)
|
||
).all():
|
||
bucket(str(provider or ""), str(model or ""))["assets"] += int(count or 0)
|
||
|
||
p_of = func.json_extract(PlatformMedia.metadata_json, "$.provider")
|
||
m_of = func.json_extract(PlatformMedia.metadata_json, "$.model")
|
||
for provider, model, count in db.execute(
|
||
select(p_of, m_of, func.count(PlatformMedia.id))
|
||
.where(p_of.isnot(None), p_of != "")
|
||
.group_by(p_of, m_of)
|
||
).all():
|
||
bucket(str(provider or ""), str(model or ""))["assets"] += int(count or 0)
|
||
|
||
for provider, model, calls, seconds, cost, last_used in db.execute(
|
||
select(GenerationRecord.provider, GenerationRecord.model,
|
||
func.count(GenerationRecord.id),
|
||
func.coalesce(func.sum(GenerationRecord.duration_seconds), 0.0),
|
||
func.coalesce(func.sum(GenerationRecord.cost), 0.0),
|
||
func.max(GenerationRecord.created_at))
|
||
.group_by(GenerationRecord.provider, GenerationRecord.model)
|
||
).all():
|
||
entry = bucket(str(provider or ""), str(model or ""))
|
||
entry["calls"] += int(calls or 0)
|
||
entry["seconds"] += float(seconds or 0.0)
|
||
entry["cost"] += float(cost or 0.0)
|
||
if last_used and str(last_used) > str(entry["last_used"] or ""):
|
||
entry["last_used"] = str(last_used)
|
||
for entry in usage.values():
|
||
entry["seconds"] = round(entry["seconds"], 2)
|
||
entry["cost"] = round(entry["cost"], 4)
|
||
return usage
|
||
|
||
|
||
def _upscale_tiers(spec) -> list[str]:
|
||
"""放大交付档位(适配器/模型配置声明)。取不到就当没这个能力,不参与下拉。"""
|
||
try:
|
||
return list(model_registry.capabilities_of(spec).upscale_to or ())
|
||
except Exception: # noqa: BLE001 - 列表接口不能被能力探测打挂
|
||
return []
|
||
|
||
|
||
@router.get("/api/providers")
|
||
def list_specs(db: Session = Depends(get_db)):
|
||
rows = db.scalars(select(ModelSpec).order_by(ModelSpec.provider, ModelSpec.model)).all()
|
||
load = {f"{row['provider']}|{row['model']}": row
|
||
for row in (r.as_dict() for r in capacity.snapshot(db))}
|
||
usage = _usage_index(db)
|
||
payload = []
|
||
for spec in rows:
|
||
key = f"{spec.provider}|{spec.model or ''}"
|
||
payload.append({
|
||
"id": spec.id, "provider": spec.provider, "model": spec.model,
|
||
"display_name": spec.display_name or spec.model, "media_type": spec.media_type,
|
||
"adapter": spec.adapter, "enabled": spec.enabled, "is_default": spec.is_default,
|
||
"status": spec.status, "model_code": spec.model_code or "",
|
||
"timeout_seconds": spec.timeout_seconds or 120,
|
||
"has_api_key": bool(spec.api_key_encrypted),
|
||
"api_key_masked": secrets.mask_value(
|
||
secrets.decrypt_value(db, spec.api_key_encrypted or "")
|
||
) if spec.api_key_encrypted else "",
|
||
"max_concurrency": spec.max_concurrency,
|
||
"requests_per_minute": spec.requests_per_minute, "burst": spec.burst,
|
||
"modes": spec.modes or [], "resolutions": spec.resolutions or [],
|
||
# 「原生能生成」与「能交付」的档位不同:H3 原生 768p,1080p 靠合成端放大交付。
|
||
# 前端下拉框要按这个差异加标注,否则用户以为选到 1080p 就多花了卡时。
|
||
"upscale_to": _upscale_tiers(spec),
|
||
"aspect_ratios": spec.aspect_ratios or [], "min_duration": spec.min_duration,
|
||
"max_duration": spec.max_duration, "max_reference_images": spec.max_reference_images,
|
||
"price_per_second": spec.price_per_second, "price_per_1k_chars": spec.price_per_1k_chars,
|
||
"currency": spec.currency, "default_params": spec.default_params or {},
|
||
"config": _redact_config(spec.config_json or {}), "notes": spec.notes,
|
||
"uses_mock": spec.provider == "mock" or str(spec.adapter or "").startswith("mock"),
|
||
# 故障注入是临时态:列表与页头都要显性提示,避免脚本中断后整条能力被静默打挂
|
||
"fault_injection": round(float((spec.config_json or {}).get("failure_rate") or 0.0), 4),
|
||
"requires_reference": spec.adapter == "comfyui_tts",
|
||
"available": model_registry.is_available(spec, db),
|
||
"load": load.get(key, {}),
|
||
# 调用量:模型卡要能看出「这条能力真的在跑活」,而不只是「配置看起来没问题」
|
||
"usage": usage.get(key, {"calls": 0, "seconds": 0.0, "cost": 0.0, "assets": 0,
|
||
"last_used": None}),
|
||
})
|
||
defaults = {}
|
||
for media_type in ("llm", "video", "image", "tts"):
|
||
row = next((p for p in payload if p["media_type"] == media_type and p["is_default"]), None)
|
||
defaults[f"{media_type}_provider"] = row["provider"] if row else ""
|
||
defaults[f"{media_type}_model"] = row["model"] if row else ""
|
||
# 环境变量只是历史兜底:必须能拼出注册表里真实存在、且当前启用可用的「provider|model 对」
|
||
# 才允许覆盖默认。以前只覆盖 provider、留下库里默认行的 model,会凭空造出
|
||
# mock|indextts2 这种谁都没登记过的组合,前端只能靠多级回落勉强命中,看着对其实错。
|
||
for media_type, env_provider, env_model in (
|
||
("video", settings.video_provider, settings.video_model or defaults["video_model"]),
|
||
("tts", settings.tts_provider, defaults["tts_model"]),
|
||
):
|
||
if not env_provider:
|
||
continue
|
||
pair = next((p for p in payload if p["media_type"] == media_type
|
||
and p["provider"] == env_provider and p["model"] == env_model
|
||
and p["enabled"] and p["available"]), None)
|
||
if pair:
|
||
defaults[f"{media_type}_provider"], defaults[f"{media_type}_model"] = pair["provider"], pair["model"]
|
||
return {"providers": payload, "defaults": defaults,
|
||
"media_types": MODEL_MEDIA_TYPES, "adapters": MODEL_ADAPTERS}
|
||
|
||
|
||
@router.post("/api/providers")
|
||
def create_spec(data: schemas.ModelSpecCreate, db: Session = Depends(get_db)):
|
||
payload = data.model_dump()
|
||
api_key = payload.pop("api_key", None)
|
||
if payload["media_type"] not in MODEL_ADAPTERS:
|
||
raise HTTPException(400, f"不支持的模型类型:{payload['media_type']}")
|
||
if payload["adapter"] not in MODEL_ADAPTERS[payload["media_type"]]:
|
||
raise HTTPException(400, f"{payload['media_type']} 模型不支持适配器 {payload['adapter']};"
|
||
f"可用:{', '.join(MODEL_ADAPTERS[payload['media_type']])}")
|
||
_validate_model_code(db, payload.get("model_code", ""))
|
||
config = payload.pop("config", {}) or {}
|
||
_normalize_config(config, payload)
|
||
spec = ModelSpec(**payload, config_json=config)
|
||
if api_key:
|
||
spec.api_key_encrypted = secrets.encrypt_value(db, str(api_key).strip())
|
||
if not spec.display_name:
|
||
spec.display_name = spec.model or spec.provider
|
||
if spec.is_default:
|
||
db.query(ModelSpec).filter(ModelSpec.media_type == spec.media_type,
|
||
ModelSpec.is_default.is_(True)).update({"is_default": False})
|
||
db.add(spec)
|
||
db.flush()
|
||
events.log_event(db, "model.created", message=f"注册模型 {spec.provider}/{spec.model}",
|
||
entity_type="model_spec", entity_id=spec.id,
|
||
data={"media_type": spec.media_type, "adapter": spec.adapter,
|
||
"model_code": spec.model_code or ""})
|
||
db.commit()
|
||
return {"ok": True, "id": spec.id}
|
||
|
||
|
||
@router.patch("/api/providers/{spec_id}")
|
||
def update_spec(spec_id: int, data: schemas.ModelSpecUpdate, db: Session = Depends(get_db)):
|
||
spec = db.get(ModelSpec, spec_id)
|
||
if spec is None:
|
||
raise HTTPException(404, "模型不存在")
|
||
patch = data.model_dump(exclude_unset=True)
|
||
api_key = str(patch.pop("api_key", "") or "").strip()
|
||
clear_api_key = bool(patch.pop("clear_api_key", False))
|
||
if patch.get("media_type") and patch["media_type"] not in MODEL_ADAPTERS:
|
||
raise HTTPException(400, f"不支持的模型类型:{patch['media_type']}")
|
||
media_type = patch.get("media_type") or spec.media_type
|
||
adapter = patch.get("adapter") or spec.adapter
|
||
if adapter not in MODEL_ADAPTERS.get(media_type, []):
|
||
raise HTTPException(400, f"{media_type} 模型不支持适配器 {adapter};"
|
||
f"可用:{', '.join(MODEL_ADAPTERS.get(media_type, []))}")
|
||
config = patch.pop("config", None)
|
||
replace_config = bool(patch.pop("replace_config", False))
|
||
_validate_model_code(db, patch.get("model_code", ""), exclude_id=spec_id)
|
||
if media_type == "llm":
|
||
patch["modes"] = [mode for mode in patch.get("modes", spec.modes or [])
|
||
if mode in ("chat", "prompt")]
|
||
patch["max_reference_images"] = 0
|
||
patch["aspect_ratios"] = []
|
||
current_config = dict(spec.config_json or {})
|
||
if "image" in current_config:
|
||
current_config.pop("image", None)
|
||
spec.config_json = current_config
|
||
if config is not None:
|
||
# 只传一个键就把整份 config 覆盖掉,等于悄悄删掉 base_url / workflow / models,
|
||
# 模型随即不可用(PATCH 仍返回 200)。默认改成浅合并,全量替换要显式声明。
|
||
merged = dict(config) if replace_config else {**(spec.config_json or {}), **config}
|
||
config_diff = _diff_config(spec.config_json or {}, merged)
|
||
_normalize_config(merged, {**{
|
||
"provider": patch.get("provider", spec.provider),
|
||
"model": patch.get("model", spec.model),
|
||
"media_type": patch.get("media_type", spec.media_type),
|
||
}})
|
||
spec.config_json = merged
|
||
if patch.get("is_default"):
|
||
db.query(ModelSpec).filter(ModelSpec.media_type == (patch.get("media_type") or spec.media_type),
|
||
ModelSpec.is_default.is_(True)).update({"is_default": False})
|
||
for key, value in patch.items():
|
||
setattr(spec, key, value)
|
||
if clear_api_key:
|
||
spec.api_key_encrypted = ""
|
||
elif api_key and "*" not in api_key:
|
||
spec.api_key_encrypted = secrets.encrypt_value(db, api_key)
|
||
db.flush()
|
||
log_data = _redact_config(patch)
|
||
if config is not None:
|
||
# 台账里写清这次是「合并」还是「整份替换」,避免再被误当成全量提交
|
||
log_data["config_mode"] = "replace" if replace_config else "merge"
|
||
log_data["config_keys"] = sorted(config)
|
||
# 模型控制台保存的是整份 config 快照:表单打开后配置若被别处改过(或直接改库),
|
||
# 保存就会把旧值静默写回。台账里留一份新旧对照,出问题能追责。
|
||
if config_diff:
|
||
log_data["config_changes"] = config_diff
|
||
events.log_event(db, "model.updated", message=f"更新模型 {spec.provider}/{spec.model}",
|
||
entity_type="model_spec", entity_id=spec.id, data=log_data)
|
||
db.commit()
|
||
return {"ok": True, "id": spec.id}
|
||
|
||
|
||
@router.delete("/api/providers/{spec_id}")
|
||
def delete_spec(spec_id: int, db: Session = Depends(get_db)):
|
||
spec = db.get(ModelSpec, spec_id)
|
||
if spec is None:
|
||
raise HTTPException(404, "模型不存在")
|
||
running = db.query(Task).filter(Task.provider == spec.provider, Task.model == spec.model,
|
||
Task.status.in_(TaskStatus.ACTIVE)).count()
|
||
if running:
|
||
raise HTTPException(409, f"仍有 {running} 个任务使用该模型,请先停用而非删除")
|
||
db.delete(spec)
|
||
events.log_event(db, "model.deleted", message=f"删除模型 {spec.provider}/{spec.model}",
|
||
entity_type="model_spec", entity_id=spec_id)
|
||
db.commit()
|
||
return {"ok": True}
|
||
|
||
|
||
@router.get("/api/providers/{spec_id}/api-key")
|
||
def reveal_api_key(spec_id: int, db: Session = Depends(get_db),
|
||
actor: User = Depends(require_admin)) -> dict:
|
||
"""取回某条模型已保存的 API Key 明文(供页面上的「眼睛」图标显示)。
|
||
|
||
列表接口只回 `sk-****abcd` 掩码,所以用户点「显示」时输入框是空的——看起来像坏了。
|
||
明文只在这里按需下发:仅管理员、只读、并在审计流水里留一条痕(谁看了哪条密钥)。
|
||
"""
|
||
spec = db.get(ModelSpec, spec_id)
|
||
if spec is None:
|
||
raise HTTPException(404, "模型不存在")
|
||
plain = secrets.decrypt_value(db, spec.api_key_encrypted) if spec.api_key_encrypted else ""
|
||
auth_service.log_audit(db, "model.api_key_revealed",
|
||
message=f"{actor.username} 查看模型密钥 {spec.provider}/{spec.model}",
|
||
entity_type="model_spec", entity_id=spec_id, actor=actor)
|
||
db.commit()
|
||
return {"ok": True, "result": {"api_key": plain, "provider": spec.provider,
|
||
"model": spec.model, "set": bool(plain)}}
|
||
|
||
|
||
@router.get("/api/providers/{spec_id}/probe")
|
||
def probe_spec(spec_id: int, db: Session = Depends(get_db)):
|
||
"""探测模型是否真的可用;ComfyUI 额外返回连通性、显存、队列与可用模型文件名。"""
|
||
spec = db.get(ModelSpec, spec_id)
|
||
if spec is None:
|
||
raise HTTPException(404, "模型不存在")
|
||
adapter = model_registry.adapter_for_spec(spec)
|
||
info: dict = {"provider": spec.provider, "model": spec.model, "adapter": spec.adapter,
|
||
"available": False, "message": ""}
|
||
runtime: dict = {}
|
||
try:
|
||
runtime = model_registry.runtime_config(db, spec)
|
||
# 显式探测要拿真实结果,不能复用列表页那份 30s 缓存
|
||
if hasattr(adapter, "invalidate_probes"):
|
||
adapter.invalidate_probes(runtime)
|
||
# 生成链路上的「开工前探活」是另一份共享缓存(providers/comfy_common.py)。
|
||
# 出片失败时我们让用户「到模型中心点探测复测」,那这个按钮就必须真的把那份
|
||
# 缓存打穿并回填——否则会出现「页面刚探测通过、任务还是说连不上」。
|
||
base = str(runtime.get("base_url") or runtime.get("url") or "").strip().rstrip("/")
|
||
if base and (spec.provider == "comfyui" or str(spec.adapter or "").startswith("comfy")):
|
||
comfy_common.invalidate_reachability(base)
|
||
reachable, why = comfy_common.probe_reachable(base, timeout=8.0, force=True)
|
||
info["reachable"] = reachable
|
||
if not reachable:
|
||
info["message"] = info.get("message") or f"连不上 {base}:{why}"
|
||
if hasattr(adapter, "diagnose"):
|
||
info.update(adapter.diagnose(runtime))
|
||
else:
|
||
info["available"] = bool(adapter.is_available(runtime))
|
||
info["message"] = "适配器可用" if info["available"] else "适配器未配置或缺少依赖"
|
||
except Exception as exc: # 诊断绝不能把页面打挂
|
||
info["message"] = f"探测失败:{type(exc).__name__}: {exc}"
|
||
caps = model_registry.capabilities_of(spec)
|
||
info["capabilities"] = caps.as_dict()
|
||
# 声明档位 ≠ 实际交付像素:把「这个配置真正会出多大画面」摊开给控制台看
|
||
try:
|
||
info["canvas"] = {ar: list(adapter.effective_canvas(runtime, ar) or ())
|
||
for ar in (caps.aspect_ratios or ())}
|
||
except Exception: # noqa: BLE001 - 诊断字段不参与主流程
|
||
info["canvas"] = {}
|
||
return info
|
||
|
||
|
||
def _validate_model_code(db: Session, code: str, *, exclude_id: int | None = None) -> None:
|
||
code = (code or "").strip()
|
||
if not code:
|
||
return
|
||
stmt = select(ModelSpec).where(ModelSpec.model_code == code)
|
||
if exclude_id is not None:
|
||
stmt = stmt.where(ModelSpec.id != exclude_id)
|
||
if db.scalars(stmt).first():
|
||
raise HTTPException(409, f"模型编码 {code} 已被占用,请换一个")
|
||
|
||
|
||
def _normalize_config(config: dict, payload: dict) -> None:
|
||
"""把控制台级字段同步进适配器配置,避免两处填写不一致。"""
|
||
if payload.get("media_type") == "llm":
|
||
# LLM 只负责语言推理。图像生成统一走 image 模型,避免同一模型
|
||
# 在两套端点/尺寸配置之间产生歧义,也清理旧版本遗留的 image 配置。
|
||
for key in ("image", "temperature", "top_p", "max_tokens"):
|
||
config.pop(key, None)
|
||
if "modes" in payload:
|
||
payload["modes"] = [mode for mode in (payload.get("modes") or [])
|
||
if mode in ("chat", "prompt")]
|
||
payload["max_reference_images"] = 0
|
||
payload["aspect_ratios"] = []
|
||
if payload.get("model"):
|
||
config.setdefault("model", payload["model"])
|
||
base = str(config.get("base_url") or "").rstrip("/")
|
||
if base:
|
||
config["base_url"] = base
|
||
|
||
|
||
def _diff_config(old: dict, new: dict) -> dict:
|
||
"""新旧配置的标量差异({"key": {"from":…, "to":…}}),嵌套结构只标记 changed。"""
|
||
diff: dict = {}
|
||
for key in sorted(set(old) | set(new)):
|
||
if key not in new:
|
||
diff[key] = {"from": _brief(old.get(key)), "to": None}
|
||
continue
|
||
if key not in old:
|
||
diff[key] = {"from": None, "to": _brief(new.get(key))}
|
||
continue
|
||
before, after = old.get(key), new.get(key)
|
||
if before == after:
|
||
continue
|
||
if isinstance(before, (int, float, str, bool)) or before is None:
|
||
diff[key] = {"from": _brief(before), "to": _brief(after)}
|
||
else:
|
||
diff[key] = {"changed": True}
|
||
return diff
|
||
|
||
|
||
def _brief(value):
|
||
if isinstance(value, (int, float, str, bool)) or value is None:
|
||
return value
|
||
text = json.dumps(value, ensure_ascii=False)
|
||
return text if len(text) <= 160 else text[:157] + "..."
|
||
|
||
|
||
def _redact_config(value):
|
||
if isinstance(value, dict):
|
||
out = {}
|
||
for key, item in value.items():
|
||
lowered = str(key).lower()
|
||
if (lowered in {"api_key", "apikey", "access_token", "secret", "password"}
|
||
or lowered.endswith("_api_key")
|
||
or lowered.endswith("_secret")
|
||
or lowered.endswith("_password")):
|
||
out[key] = "***" if item else ""
|
||
else:
|
||
out[key] = _redact_config(item)
|
||
return out
|
||
if isinstance(value, list):
|
||
return [_redact_config(item) for item in value]
|
||
return value
|
||
|
||
|
||
@router.get("/api/events")
|
||
def global_events(limit: int = 80, level: str = "", db: Session = Depends(get_db)):
|
||
rows = events.recent_events(db, limit=min(500, max(1, limit)))
|
||
if level:
|
||
rows = [r for r in rows if r["level"] == level]
|
||
return {"events": rows}
|