接入 DSH 专用运行时和对话界面,保留模型原始回答,支持会话分页、连续追问与显式报告。 补齐组合筛选、各维度 Top100、分组查询到排名图的转换,图表故障静默省略并基于保存数据自动恢复。 优化报告风格、图表顺序和表格换行,更新接入说明及构建输入。 验证:独立目录前后端构建通过;118 项 Java、102 项前端、102 项图表、14 项 DSH 应用和 13 项组合筛选检查通过。 仅提交相关源码、锁定依赖与测试;不包含凭据、会话、业务数据或本地产物。
355 lines
20 KiB
Python
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)
|