同步:完善质量分析工作台并更新主题字体

同步已上线的智能分析执行协议、来源查询、图表报告与管理页面配套代码。
补齐数据库迁移、运行依赖和回归测试,保留原有指标计算口径。
统一午夜黑及其他主题的控件细节、中文和业务数字字体。
排除本地业务数据、凭据、预览、发布与验收产物。

验证:生产构建通过,320项前端回归通过;本轮仅同步Git,不再次部署。
This commit is contained in:
2026-10-30 22:40:58 +08:00
parent edef747e3b
commit ff7bbe3e46
393 changed files with 62999 additions and 1783 deletions
+249
View File
@@ -0,0 +1,249 @@
"""Per-turn loopback model gate. Provider credentials never enter the native model process."""
from __future__ import annotations
import contextlib
import hmac
import json
import secrets
import ssl
import threading
import time
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from typing import Callable
from urllib.error import HTTPError
from urllib.parse import urlsplit
from urllib.request import HTTPRedirectHandler, HTTPSHandler, Request, build_opener
class _NoRedirect(HTTPRedirectHandler):
def redirect_request(self, *_args, **_kwargs):
return None
class ModelGate:
"""A stable per-session endpoint backed only by this turn's live delegation."""
def __init__(self, *, upstream_base: str, upstream_key: str, model: str,
port: int, client_key: str, authorize: Callable[[], None], thinking_options=None, on_thinking=None,
native_turn_marker: str | None = None) -> None:
parsed = urlsplit(upstream_base)
if parsed.scheme not in ('http', 'https') or not parsed.hostname or parsed.username or parsed.query or parsed.fragment:
raise ValueError('模型接口地址无效。')
self.base_url = f'http://127.0.0.1:{port}/v1'
self.client_key = client_key
self._upstream = upstream_base.rstrip('/') + '/chat/completions'
self._upstream_key = upstream_key
self._model = model
from nao_runtime_policy import turn_deadline
self._deadline = turn_deadline()
self._authorize = authorize
self._thinking = dict(thinking_options) if thinking_options is not None else None
self._on_thinking = on_thinking
self._native_turn_marker = native_turn_marker
self.rejected_stale_requests = 0
self._request_number = 0
self._request_prefix = secrets.token_hex(4)
self.request_audit = []
self._audit_lock = threading.Lock()
self._closed = threading.Event()
bundle = Path('/etc/ssl/cert.pem')
trust = ssl.create_default_context(cafile=str(bundle) if bundle.is_file() else None)
self._opener = build_opener(_NoRedirect(), HTTPSHandler(context=trust))
gate = self
class Handler(BaseHTTPRequestHandler):
protocol_version = 'HTTP/1.0'
def log_message(self, *_):
pass # Never log authorization headers, model text, or provider errors.
def failure(self, status: int, message: str) -> None:
data = json.dumps({'error': {'message': message}}, ensure_ascii=False).encode()
self.send_response(status)
self.send_header('Content-Type', 'application/json')
self.send_header('Content-Length', str(len(data)))
self.send_header('Cache-Control', 'no-store')
self.end_headers()
with contextlib.suppress(OSError):
self.wfile.write(data)
def do_POST(self) -> None:
if self.path != '/v1/chat/completions':
self.failure(404, '模型路由未开放'); return
expected = 'Bearer ' + gate.client_key
if not hmac.compare_digest(self.headers.get('Authorization', ''), expected):
self.failure(403, '模型请求未授权'); return
phase = self.headers.get('X-Quality-Analysis-Phase','analysis')
if phase not in ('planning','analysis','repair','finalizing'):phase='analysis'
try:
length = int(self.headers.get('Content-Length', '0'))
if not 0 < length <= 4 * 1024 * 1024:
raise ValueError()
payload = self.rfile.read(length)
decoded = json.loads(payload)
if not isinstance(decoded, dict) or decoded.get('model') != gate._model:
raise ValueError()
if phase == 'analysis' and gate._native_turn_marker is not None:
messages = decoded.get('messages')
if not (isinstance(messages, list) and any(isinstance(message, dict)
and message.get('role') == 'user'
and gate._native_turn_marker in json.dumps(message.get('content'), ensure_ascii=False)
for message in messages)):
with gate._audit_lock: gate.rejected_stale_requests += 1
self.failure(403, '模型请求不属于当前轮次'); return
decoded = gate.apply_thinking(decoded)
from nao_agent_contract import apply_platform_tools
decoded = apply_platform_tools(decoded)
payload = json.dumps(decoded,ensure_ascii=False).encode()
except (ValueError, OSError):
self.failure(400, '模型请求格式无效'); return
try:
gate._check()
except Exception:
self.failure(403, '模型服务授权已失效'); return
client_stream = bool(decoded.get('stream'))
bridge = gate._on_thinking is not None and not client_stream
if bridge:
decoded['stream'] = True
decoded['stream_options'] = {**(decoded.get('stream_options') or {}),'include_usage':True}
payload = json.dumps(decoded,ensure_ascii=False).encode()
with gate._audit_lock:
gate._request_number += 1
request_id = f'api-{gate._request_prefix}-{gate._request_number}'
thought_base = {'id':request_id,'phase':phase,'model':gate._model,'streaming':True}
def thinking(event, **fields):
if gate._on_thinking is not None and not gate._closed.is_set():
gate._on_thinking({**thought_base,'event':event,**fields})
outgoing = Request(gate._upstream, data=payload, method='POST', headers={
'Content-Type': 'application/json', 'Authorization': 'Bearer ' + gate._upstream_key,
'Accept': self.headers.get('Accept', 'application/json')})
headers_sent = False
thought_ended = False
try:
from nao_runtime_policy import REQUEST_TIMEOUT_SECONDS
remaining = max(0, gate._deadline-time.monotonic()) if gate._deadline is not None else REQUEST_TIMEOUT_SECONDS
if remaining <= 0: raise TimeoutError('本轮分析时限已到')
timeout = min(remaining, 90 if decoded.get('stream') else REQUEST_TIMEOUT_SECONDS)
try:
response = gate._opener.open(outgoing, timeout=timeout)
except HTTPError as error:
if not bridge or error.code not in (400,422):raise
# Some compatible providers only support whole JSON responses.
decoded['stream'] = False;decoded.pop('stream_options',None)
outgoing.data = json.dumps(decoded,ensure_ascii=False).encode()
response = gate._opener.open(outgoing,timeout=min(remaining,REQUEST_TIMEOUT_SECONDS))
with response:
gate._check()
from nao_thinking_stream import ProviderStream
is_sse = 'text/event-stream' in response.headers.get('Content-Type','')
thought_base['streaming'] = is_sse
thinking('start')
# SSE termination is a transport concern even when no thinking
# callback is installed (for example, native stream forwarding).
observer = ProviderStream(lambda text:thinking('delta',text=text)) if gate._on_thinking or is_sse else None
raw_json = bytearray()
if not bridge:
self.send_response(response.status)
self.send_header('Content-Type', response.headers.get('Content-Type', 'application/json'))
self.send_header('Cache-Control', 'no-store')
self.end_headers()
headers_sent = True
checked_at = time.monotonic()
total = 0
while not gate._closed.is_set():
chunk = response.read1(8192)
if not chunk:
break
total += len(chunk)
if total > 20 * 1024 * 1024:
raise ValueError('模型响应过大')
if time.monotonic() - checked_at >= 1:
gate._check()
checked_at = time.monotonic()
if observer:
if is_sse:observer.feed(chunk)
else:raw_json.extend(chunk)
if not bridge:
self.wfile.write(chunk)
self.wfile.flush()
# A provider may keep the HTTP connection alive with heartbeats
# after its explicit terminal event. Do not wait for EOF, but
# keep reading past finish_reason so the usage tail is preserved.
if is_sse and observer.done:
break
gate._check()
if observer:
if is_sse:observer.finish()
else:observer.document(json.loads(raw_json))
result = observer.completion() if bridge or is_sse else None
stops = [row['finish_reason'] for row in observer.choices.values()] if observer else []
thinking('end',finishReason='length' if 'length' in stops else (stops[-1] if stops else ''),interrupted=bool(observer and not stops))
thought_ended=True
if bridge:
for choice in result['choices']:
choice['message'].pop('reasoning',None)
choice['message'].pop('reasoning_content',None)
encoded = json.dumps(result,ensure_ascii=False).encode()
self.send_response(200);self.send_header('Content-Type','application/json')
self.send_header('Cache-Control','no-store');self.send_header('Content-Length',str(len(encoded)))
self.end_headers();headers_sent=True;self.wfile.write(encoded);self.wfile.flush()
except HTTPError as error:
if not headers_sent:
self.failure(error.code if 400 <= error.code <= 599 else 502, '模型接口暂不可用')
except Exception:
if not headers_sent:
self.failure(502, '模型接口暂不可用或授权已失效')
finally:
if not thought_ended:thinking('end',interrupted=True)
class Server(ThreadingHTTPServer):
allow_reuse_address = True
daemon_threads = True
self._server = Server(('127.0.0.1', port), Handler)
self._thread = threading.Thread(target=self._server.serve_forever, name='nao-model-gate', daemon=True)
self._thread.start()
def apply_thinking(self, payload):
from nao_runtime_policy import MAX_OUTPUT_TOKENS
payload.pop('max_tokens', None)
payload['max_completion_tokens'] = MAX_OUTPUT_TOKENS
options = self._thinking
if options is None:return payload
enabled,effort,protocol=options.get('enabled'),options.get('effort'),options.get('protocol')
if type(enabled) is not bool or effort not in ('auto','low','medium','high') or protocol not in ('thinking','chat_template'):
raise ValueError('思考配置无效')
payload.pop('thinking',None);payload.pop('enable_thinking',None);payload.pop('reasoning_effort',None)
if protocol=='chat_template':
extra=payload.get('chat_template_kwargs')
payload['chat_template_kwargs']={**(extra if isinstance(extra,dict) else {}),'enable_thinking':enabled}
payload['chat_template_kwargs'].pop('reasoning_effort',None)
else:
payload.pop('chat_template_kwargs',None)
payload['thinking']={'type':'enabled' if enabled else 'disabled'}
if enabled:
payload.pop('temperature',None);payload.pop('top_p',None)
if effort!='auto':
if protocol=='chat_template' and self._model.lower().startswith('qwen3.8'):
payload['chat_template_kwargs']['reasoning_effort']='xhigh' if effort=='high' else effort
else:payload['reasoning_effort']=effort
with self._audit_lock:
if len(self.request_audit)<200:self.request_audit.append({'enabled':enabled,'effort':effort,
'protocol':protocol,'stream':payload.get('stream',False),
'maxCompletionTokens':payload.get('max_completion_tokens',payload.get('max_tokens')),
'thinkingType':(payload.get('thinking') or {}).get('type'),
'chatTemplateEnabled':(payload.get('chat_template_kwargs') or {}).get('enable_thinking'),
'reasoningEffort':payload.get('reasoning_effort',(payload.get('chat_template_kwargs') or {}).get('reasoning_effort'))})
return payload
def _check(self) -> None:
if self._closed.is_set():
raise PermissionError('模型授权已关闭')
self._authorize()
def close(self) -> None:
self._closed.set()
self._server.shutdown()
self._server.server_close()
self._thread.join(timeout=1)