Files
quality_analyse/scripts/nao_model_gate.py
lyun 52d92c95d8 修复:智能分析空回答与工具结束条件冲突
统一自主分析工具范围与执行前校验,严格核验正常结束、最终正文和图表恢复状态,并显示空回答及恢复失败原因。

包含两次已上线修复及回归测试,保留已有回答与业务数据。

验证:1101 项 Python、469 项前端、97 项后端测试通过;前后端构建和真实模型、页面验收通过。
2026-11-03 08:56:49 +08:00

287 lines
16 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 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 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) -> 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.native_agent = False
self.rejected_stale_requests = 0
self.rejected_tool_calls = 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
from nao_agent_contract import apply_platform_tools
decoded = apply_platform_tools(decoded, native_agent=gate.native_agent)
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
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))
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:
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: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 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 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,
'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
raise ToolPolicyError('Unadvertised tool call')
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)