同步:完善质量分析工作台并更新主题字体
同步已上线的智能分析执行协议、来源查询、图表报告与管理页面配套代码。 补齐数据库迁移、运行依赖和回归测试,保留原有指标计算口径。 统一午夜黑及其他主题的控件细节、中文和业务数字字体。 排除本地业务数据、凭据、预览、发布与验收产物。 验证:生产构建通过,320项前端回归通过;本轮仅同步Git,不再次部署。
This commit is contained in:
@@ -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)
|
||||
Reference in New Issue
Block a user