Files
quality_analyse/scripts/nao_model_gate.py
T
lyun f1a2fbd494 统一:DSH 智能分析、Top100 与图表静默恢复
接入 DSH 专用运行时和对话界面,保留模型原始回答,支持会话分页、连续追问与显式报告。
补齐组合筛选、各维度 Top100、分组查询到排名图的转换,图表故障静默省略并基于保存数据自动恢复。
优化报告风格、图表顺序和表格换行,更新接入说明及构建输入。

验证:独立目录前后端构建通过;118 项 Java、102 项前端、102 项图表、14 项 DSH 应用和 13 项组合筛选检查通过。
仅提交相关源码、锁定依赖与测试;不包含凭据、会话、业务数据或本地产物。
2026-11-12 11:57:41 +08:00

355 lines
20 KiB
Python

"""Per-turn loopback model gate. Provider credentials never enter the native model process."""
from __future__ import annotations
import contextlib
import hmac
import json
import re
import secrets
import socket
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
from nao_tool_stream import ToolStreamNormalizer, ToolStreamProtocolError
class _NoRedirect(HTTPRedirectHandler):
def redirect_request(self, *_args, **_kwargs):
return None
class ToolPolicyError(ValueError):
pass
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, runtime_engine: str = 'NAO') -> None:
if runtime_engine not in ('NAO', 'DSH'):
raise ValueError('分析引擎无效。')
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.native_agent = False
self.runtime_engine = runtime_engine
self.rejected_stale_requests = 0
self.rejected_tool_calls = 0
self.rejected_tool_names = []
self.tool_stream_failures = []
self.tool_stream_diagnostics = []
self._request_number = 0
self._request_prefix = secrets.token_hex(4)
self.request_audit = []
self._audit_lock = threading.Lock()
self._closed = threading.Event()
self._responses = set()
self._responses_lock = threading.Lock()
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
from nao_agent_contract import apply_platform_tools
decoded = apply_platform_tools(decoded, native_agent=gate.native_agent,
runtime_engine=gate.runtime_engine)
decoded = gate.apply_thinking(decoded)
offered_tools = {tool['function']['name'] for tool in decoded.get('tools', [])}
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
response = None
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 gate._responses_lock:
gate._responses.add(response)
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))
tool_stream = ToolStreamNormalizer(offered_tools) if is_sse and gate.runtime_engine == 'DSH' else None
raw_json = bytearray()
pending_wire = bytearray()
if is_sse and 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 is_sse:
if tool_stream is not None:
chunk = tool_stream.feed(chunk)
observer.feed(chunk)
gate.check_returned_tools(observer, offered_tools)
if not bridge:
# A partial SSE line cannot be checked yet. Hold
# it until its complete event has passed policy.
pending_wire.extend(chunk)
end=pending_wire.rfind(b'\n')+1
if end:
self.wfile.write(pending_wire[:end]);self.wfile.flush()
del pending_wire[:end]
else:raw_json.extend(chunk)
# 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 is_sse:
if tool_stream is not None:
tail = tool_stream.finish()
observer.feed(tail)
if not bridge: pending_wire.extend(tail)
observer.finish()
else:observer.document(json.loads(raw_json))
gate.check_returned_tools(observer, offered_tools, final=True)
if is_sse and not bridge and pending_wire:
self.wfile.write(pending_wire);self.wfile.flush()
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()
elif not is_sse:
self.send_response(response.status);self.send_header('Content-Type','application/json')
self.send_header('Cache-Control','no-store');self.send_header('Content-Length',str(len(raw_json)))
self.end_headers();headers_sent=True;self.wfile.write(raw_json);self.wfile.flush()
except ToolStreamProtocolError as error:
with gate._audit_lock:
if len(gate.tool_stream_failures) < 20:
gate.tool_stream_failures.append(error.code)
gate.tool_stream_diagnostics.append({'code': error.code, 'phase': phase,
'offered': sorted(offered_tools), 'names': error.tool_names})
if not headers_sent:self.failure(502,'模型工具响应格式异常,请重试本轮')
else:
with contextlib.suppress(OSError):
self.wfile.write(b'data: {"error":{"message":"Invalid tool stream framing"}}\n\n');self.wfile.flush()
except ToolPolicyError:
if not headers_sent:self.failure(502,'模型返回了当前任务未开放的工具调用')
else:
with contextlib.suppress(OSError):
self.wfile.write(b'data: {"error":{"message":"Tool call is unavailable for this task"}}\n\n');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 response is not None:
with gate._responses_lock:
gate._responses.discard(response)
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('思考配置无效')
requested_enabled = enabled
# User-approved MiMo compatibility: its documented thinking/tool
# instability can yield incomplete argument streams. Keep the saved
# preference and non-tool requests intact; do not repair model output.
tool_thinking_override = bool(enabled and self.native_agent and payload.get('tools')
and self._model.lower().startswith('mimo-'))
if tool_thinking_override:
enabled = False
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,'requestedEnabled':requested_enabled,
'toolThinkingOverride':tool_thinking_override,'effort':effort,
'tools':[tool['function']['name'] for tool in payload.get('tools',[])],
'nativeAgent':self.native_agent,
'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_returned_tools(self, observer, offered, *, final=False):
for choice, tools in observer.tools.items():
finished=final or bool(observer.choices.get(choice,{}).get('finish_reason')) or observer.done
for tool in tools.values():
name=tool.get('function',{}).get('name','')
valid=(name in offered) if finished else (not name or any(allowed.startswith(name) for allowed in offered))
if not valid:
with self._audit_lock:
self.rejected_tool_calls += 1
# Names only: never record arguments, provider errors or
# arbitrary text masquerading as a function name.
safe_name = name if isinstance(name, str) and re.fullmatch(r'[A-Za-z_][A-Za-z0-9_.:-]{0,119}', name) else '<invalid_name>'
if safe_name not in self.rejected_tool_names and len(self.rejected_tool_names) < 20:
self.rejected_tool_names.append(safe_name)
raise ToolPolicyError('Unadvertised tool call')
def _check(self) -> None:
if self._closed.is_set():
raise PermissionError('模型授权已关闭')
self._authorize()
def revoke(self) -> None:
"""Close this turn's capability and interrupt in-flight provider reads."""
self._closed.set()
with self._responses_lock:
responses = list(self._responses)
for response in responses:
# shutdown wakes read1 before HTTPResponse.close waits on its file
# lock. No provider address, header or credential is logged here.
stream = getattr(response, 'fp', None)
raw = getattr(stream, 'raw', stream)
channel = getattr(raw, '_sock', None)
with contextlib.suppress(OSError, AttributeError):
channel.shutdown(socket.SHUT_RDWR)
with contextlib.suppress(OSError, ValueError):
response.close()
def close(self) -> None:
self.revoke()
self._server.shutdown()
self._server.server_close()
self._thread.join(timeout=1)