"""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 '' 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)