model_network.py 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391
  1. """Request-local model networking for Yaovi's embedded Hermes bridge.
  2. Policies travel on the private stdin RPC, never in config.yaml, logs or tool context.
  3. No os.environ mutation: OAuth threads retain a snapshot; other calls can change routes.
  4. HTTPX transports are selected per request (including cached SDK clients and redirects).
  5. """
  6. import contextlib
  7. import contextvars
  8. import copy
  9. import functools
  10. import hashlib
  11. import json
  12. import os
  13. from pathlib import Path
  14. import socket
  15. import threading
  16. from urllib.parse import urlsplit
  17. _context = contextvars.ContextVar("yaovi_model_network", default=None)
  18. _installed = False
  19. _auth_urls = {
  20. "openai-codex": "https://auth.openai.com/",
  21. "xai-oauth": "https://auth.x.ai/",
  22. "copilot": "https://github.com/", "copilot-acp": "https://github.com/",
  23. "qwen-oauth": "https://chat.qwen.ai/", "anthropic": "https://api.anthropic.com/",
  24. "claude-code": "https://api.anthropic.com/", "nous": "https://portal.nousresearch.com/",
  25. "minimax": "https://www.minimax.io/",
  26. }
  27. def _owns(provider):
  28. """Bot overrides apply only to Bot-owned credentials/endpoints, not parent auth."""
  29. if not os.environ.get("YAOVI_HERMES_ROOT"):
  30. return True
  31. home = Path(os.environ["HERMES_HOME"])
  32. try:
  33. auth = json.loads((home / "auth.json").read_text())
  34. if provider in (auth.get("providers") or {}) or provider in auth:
  35. return True
  36. except (OSError, ValueError):
  37. pass
  38. try:
  39. from agent.secret_scope import load_env_file
  40. from hermes_cli.providers import get_provider
  41. definition = get_provider(provider, allow_network=False)
  42. env = load_env_file(home / ".env") if (home / ".env").exists() else {}
  43. if any(env.get(key) for key in getattr(definition, "api_key_env_vars", ())):
  44. return True
  45. import yaml
  46. config = yaml.safe_load((home / "config.yaml").read_text()) or {}
  47. return provider in (config.get("providers") or {}) or any(p.get("id") == provider or p.get("name") == provider for p in config.get("custom_providers", []) if isinstance(p, dict))
  48. except (OSError, ValueError, ImportError, AttributeError):
  49. return False
  50. def _policy(ctx, provider):
  51. snapshot = ctx["snapshot"]
  52. if "botConnections" in snapshot and (ctx.get("login") or _owns(provider)):
  53. return snapshot["botConnections"].get(provider, snapshot.get("default", "environment"))
  54. return snapshot.get("connections", {}).get(provider, snapshot.get("default", "environment"))
  55. def _routes():
  56. result = []
  57. from hermes_cli.providers import HERMES_OVERLAYS, get_provider
  58. for provider in HERMES_OVERLAYS:
  59. definition = get_provider(provider, allow_network=False)
  60. if definition and definition.base_url:
  61. result.append((definition.base_url.rstrip("/"), provider))
  62. result.extend((url.rstrip("/"), provider) for provider, url in _auth_urls.items())
  63. from hermes_cli.config import load_config
  64. config = load_config()
  65. for provider, value in (config.get("providers") or {}).items():
  66. if isinstance(value, dict) and value.get("base_url"):
  67. result.append((value["base_url"].rstrip("/"), provider))
  68. for value in config.get("custom_providers") or []:
  69. if isinstance(value, dict) and value.get("base_url"):
  70. result.append((value["base_url"].rstrip("/"), value.get("id") or value.get("name") or "custom"))
  71. main = config.get("model") or {}
  72. if main.get("base_url"):
  73. result.append((main["base_url"].rstrip("/"), main.get("provider") or "custom"))
  74. return result
  75. def _credential_routes():
  76. """Bind auxiliary SDK clients that resolve API keys without runtime_provider."""
  77. from hermes_cli.providers import HERMES_OVERLAYS, get_provider
  78. from agent.secret_scope import load_env_file
  79. env = {}
  80. homes = [os.environ.get("YAOVI_HERMES_ROOT"), os.environ.get("HERMES_HOME")]
  81. for home in homes:
  82. if home and (Path(home) / ".env").exists():
  83. env.update(load_env_file(Path(home) / ".env"))
  84. env.update(os.environ)
  85. candidates = {}
  86. for provider in HERMES_OVERLAYS:
  87. definition = get_provider(provider, allow_network=False)
  88. for name in getattr(definition, "api_key_env_vars", ()):
  89. if env.get(name):
  90. key = (str(definition.base_url or "").rstrip("/"), hashlib.sha256(env[name].encode()).hexdigest())
  91. candidates.setdefault(key, set()).add(provider)
  92. return {key: next(iter(providers)) for key, providers in candidates.items() if len(providers) == 1}
  93. @contextlib.contextmanager
  94. def scope(snapshot, provider=None, *, login=False, model_operation=True):
  95. if snapshot is None:
  96. yield
  97. return
  98. ctx = {"snapshot": copy.deepcopy(snapshot), "provider": provider, "login": login,
  99. "model_operation": model_operation, "routes": _routes(), "credentials": _credential_routes()}
  100. token = _context.set(ctx)
  101. try:
  102. yield
  103. finally:
  104. _context.reset(token)
  105. def route(url, context=None):
  106. ctx = context if context is not None else _context.get()
  107. if not ctx:
  108. return "environment"
  109. if ctx.get("provider"):
  110. return _policy(ctx, ctx["provider"])
  111. target = urlsplit(str(url))
  112. matches = []
  113. for base, provider in ctx["routes"]:
  114. parsed = urlsplit(base)
  115. if (target.scheme, target.netloc) == (parsed.scheme, parsed.netloc) and (target.path == parsed.path or target.path.startswith(parsed.path.rstrip("/") + "/")):
  116. matches.append((len(parsed.path), _policy(ctx, provider)))
  117. if matches:
  118. length = max(m[0] for m in matches)
  119. policies = {p for size, p in matches if size == length}
  120. if len(policies) != 1:
  121. # Two connection identities share one endpoint; guessing could leak traffic.
  122. raise RuntimeError("同一模型地址配置了不同网络方式,请为这些连接设置相同网络。")
  123. return policies.pop()
  124. return ctx["snapshot"].get("default", "environment") if ctx["model_operation"] else "environment"
  125. def _credential_context(url, headers, ctx=None):
  126. """Direct HTTP media clients also need the identity of the bearer they resolved."""
  127. ctx = ctx if ctx is not None else _context.get()
  128. if not ctx:
  129. return ctx
  130. authorization = headers.get("authorization") or headers.get("Authorization") or ""
  131. if not authorization.lower().startswith("bearer "):
  132. return ctx
  133. fingerprint = hashlib.sha256(authorization[7:].encode()).hexdigest()
  134. target, matches = urlsplit(str(url)), []
  135. for (base, key), provider in ctx["credentials"].items():
  136. parsed = urlsplit(base)
  137. if key == fingerprint and (target.scheme, target.netloc) == (parsed.scheme, parsed.netloc) and (target.path == parsed.path or target.path.startswith(parsed.path.rstrip("/") + "/")):
  138. matches.append((len(parsed.path), provider))
  139. if matches:
  140. length = max(size for size, _ in matches)
  141. providers = {p for size, p in matches if size == length}
  142. if len(providers) == 1:
  143. return {**ctx, "provider": providers.pop()}
  144. return ctx
  145. def install():
  146. global _installed
  147. if _installed:
  148. return
  149. _installed = True
  150. import httpx
  151. # Resolve credentials under the provider's policy, including token refresh. Bind
  152. # the resulting SDK client by credentials as two suppliers may share a hostname.
  153. from hermes_cli import runtime_provider
  154. resolve = runtime_provider.resolve_runtime_provider
  155. @functools.wraps(resolve)
  156. def resolve_provider(*args, **kwargs):
  157. ctx = _context.get()
  158. provider = kwargs.get("requested") or (args[0] if args else None)
  159. token = _context.set({**ctx, "provider": provider}) if ctx and provider else None
  160. try:
  161. result = resolve(*args, **kwargs)
  162. if ctx and result.get("api_key"):
  163. key = (str(result.get("base_url") or "").rstrip("/"), hashlib.sha256(str(result["api_key"]).encode()).hexdigest())
  164. ctx["credentials"][key] = provider or result.get("provider")
  165. return result
  166. finally:
  167. if token is not None:
  168. _context.reset(token)
  169. runtime_provider.resolve_runtime_provider = resolve_provider
  170. # Native xAI media resolves OAuth/API-key credentials without runtime_provider.
  171. # Register the returned identity, rather than treating the shared origin as ambiguous.
  172. from tools import xai_http
  173. resolve_xai = xai_http.resolve_xai_http_credentials
  174. @functools.wraps(resolve_xai)
  175. def resolve_xai_credentials(*args, **kwargs):
  176. result = resolve_xai(*args, **kwargs)
  177. ctx = _context.get()
  178. if ctx and result.get("api_key") and result.get("base_url"):
  179. key = (result["base_url"].rstrip("/"), hashlib.sha256(result["api_key"].encode()).hexdigest())
  180. ctx["credentials"][key] = result["provider"]
  181. return result
  182. xai_http.resolve_xai_http_credentials = resolve_xai_credentials
  183. for cls, transport in ((httpx.Client, httpx.HTTPTransport), (httpx.AsyncClient, httpx.AsyncHTTPTransport)):
  184. original_init = cls.__init__
  185. original_select = cls._transport_for_url
  186. def make_init(original):
  187. @functools.wraps(original)
  188. def init(self, *args, **kwargs):
  189. self._yaovi_context = _context.get()
  190. self._yaovi_transports = {}
  191. self._yaovi_transport_lock = threading.Lock()
  192. self._yaovi_tls = {key: kwargs[key] for key in ("verify", "cert") if key in kwargs}
  193. original(self, *args, **kwargs)
  194. tls = getattr(getattr(self._transport, "_pool", None), "_ssl_context", None)
  195. if tls is not None:
  196. self._yaovi_tls = {"verify": tls}
  197. return init
  198. def make_select(original, transport_type):
  199. def select(self, url):
  200. ctx = _context.get() or getattr(self, "_yaovi_context", None)
  201. if ctx and getattr(self, "_yaovi_provider", None):
  202. ctx = {**ctx, "provider": self._yaovi_provider}
  203. proxy = route(url, ctx)
  204. if proxy == "environment":
  205. return original(self, url)
  206. with self._yaovi_transport_lock:
  207. if proxy not in self._yaovi_transports:
  208. self._yaovi_transports[proxy] = transport_type(proxy=proxy, trust_env=False, **self._yaovi_tls)
  209. return self._yaovi_transports[proxy]
  210. return select
  211. cls.__init__ = make_init(original_init)
  212. cls._transport_for_url = make_select(original_select, transport)
  213. original_close = httpx.Client.close
  214. def close(self):
  215. for transport in self._yaovi_transports.values():
  216. transport.close()
  217. original_close(self)
  218. httpx.Client.close = close
  219. original_aclose = httpx.AsyncClient.aclose
  220. async def aclose(self):
  221. for transport in self._yaovi_transports.values():
  222. await transport.aclose()
  223. await original_aclose(self)
  224. httpx.AsyncClient.aclose = aclose
  225. # __exit__ calls transport.__exit__ directly rather than Client.close().
  226. old_exit = httpx.Client.__exit__
  227. def exit_client(self, *args):
  228. for transport in self._yaovi_transports.values():
  229. transport.close()
  230. return old_exit(self, *args)
  231. httpx.Client.__exit__ = exit_client
  232. old_aexit = httpx.AsyncClient.__aexit__
  233. async def exit_async(self, *args):
  234. for transport in self._yaovi_transports.values():
  235. await transport.aclose()
  236. return await old_aexit(self, *args)
  237. httpx.AsyncClient.__aexit__ = exit_async
  238. # requests is used by some model catalogs. Keep its response/cookie/redirect semantics;
  239. # use HTTPX for the adapter transport so SOCKS needs no extra PySocks dependency.
  240. import requests
  241. from urllib3.response import HTTPResponse
  242. from io import BytesIO
  243. original_send = requests.adapters.HTTPAdapter.send
  244. def send(self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None):
  245. ctx = _credential_context(request.url, request.headers)
  246. proxy = route(request.url, ctx)
  247. if proxy == "environment":
  248. return original_send(self, request, stream, timeout, verify, cert, proxies)
  249. seconds = timeout if isinstance(timeout, (int, float)) else max(timeout or (30, 30))
  250. with httpx.Client(verify=verify, cert=cert, trust_env=False, timeout=seconds) as client:
  251. if ctx and ctx.get("provider"):
  252. client._yaovi_provider = ctx["provider"]
  253. response = client.request(request.method, request.url, headers=dict(request.headers), content=request.body, follow_redirects=False)
  254. raw = HTTPResponse(body=BytesIO(response.content), headers={k: v for k, v in response.headers.items() if k.lower() not in ("content-encoding", "content-length")}, status=response.status_code, preload_content=False)
  255. return self.build_response(request, raw)
  256. requests.adapters.HTTPAdapter.send = send
  257. import urllib.request
  258. import urllib.response
  259. import urllib.error
  260. from email.message import Message
  261. original_open = urllib.request.OpenerDirector.open
  262. def open_url(self, fullurl, data=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT):
  263. request = fullurl if isinstance(fullurl, urllib.request.Request) else urllib.request.Request(fullurl, data=data)
  264. if request.type not in ("http", "https") or route(request.full_url) == "environment":
  265. return original_open(self, fullurl, data, timeout)
  266. verify = next((getattr(h, "_context", None) for h in self.handlers if isinstance(h, urllib.request.HTTPSHandler) and getattr(h, "_context", None) is not None), True)
  267. with httpx.Client(verify=verify, timeout=timeout if isinstance(timeout, (int, float)) else 30, follow_redirects=True) as client:
  268. response = client.request(request.get_method(), request.full_url, headers=dict(request.header_items()), content=data if data is not None else request.data)
  269. headers = Message()
  270. for name, value in response.headers.items():
  271. if name.lower() not in ("content-encoding", "content-length"):
  272. headers[name] = value
  273. headers["Content-Length"] = str(len(response.content))
  274. if response.status_code >= 400:
  275. raise urllib.error.HTTPError(str(response.url), response.status_code, response.reason_phrase, headers, BytesIO(response.content))
  276. return urllib.response.addinfourl(BytesIO(response.content), headers, str(response.url), response.status_code)
  277. urllib.request.OpenerDirector.open = open_url
  278. original_start = threading.Thread.start
  279. def start(self, *args, **kwargs):
  280. if _context.get():
  281. context = contextvars.copy_context()
  282. run = self.run
  283. self.run = lambda: context.run(run)
  284. return original_start(self, *args, **kwargs)
  285. threading.Thread.start = start
  286. import subprocess
  287. original_popen = subprocess.Popen
  288. class ModelProcess(original_popen):
  289. def __init__(self, args, *a, **kwargs):
  290. command = kwargs.get("executable") or (args[0] if isinstance(args, (list, tuple)) and args else "")
  291. provider = {"copilot": "copilot-acp", "claude": "claude-code"}.get(Path(str(command)).stem)
  292. if provider and _context.get():
  293. env = dict(kwargs.get("env") or os.environ)
  294. route_env = process_env(provider)
  295. for key in ("HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "NO_PROXY", "http_proxy", "https_proxy", "all_proxy", "no_proxy"):
  296. env.pop(key, None)
  297. if key in route_env:
  298. env[key] = route_env[key]
  299. kwargs["env"] = env
  300. super().__init__(args, *a, **kwargs)
  301. subprocess.Popen = ModelProcess
  302. for module_name, names in (("openai", ("OpenAI", "AsyncOpenAI")), ("anthropic", ("Anthropic", "AsyncAnthropic"))):
  303. try:
  304. module = __import__(module_name)
  305. except ImportError:
  306. continue
  307. for name in names:
  308. cls = getattr(module, name)
  309. original = cls.__init__
  310. def bind(original):
  311. @functools.wraps(original)
  312. def init(self, *args, **kwargs):
  313. original(self, *args, **kwargs)
  314. ctx = _context.get()
  315. key = kwargs.get("api_key") or kwargs.get("auth_token")
  316. if ctx and key:
  317. provider = ctx["credentials"].get((str(self.base_url).rstrip("/"), hashlib.sha256(str(key).encode()).hexdigest()))
  318. if provider:
  319. self._client._yaovi_provider = provider
  320. return init
  321. cls.__init__ = bind(original)
  322. def process_env(provider):
  323. """External login subprocesses receive a private, pinned environment."""
  324. env = dict(os.environ)
  325. ctx = _context.get()
  326. proxy = _policy(ctx, provider) if ctx else "environment"
  327. if proxy != "environment":
  328. for key in ("HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "NO_PROXY", "http_proxy", "https_proxy", "all_proxy", "no_proxy"):
  329. env.pop(key, None)
  330. if proxy:
  331. env.update(HTTP_PROXY=proxy, HTTPS_PROXY=proxy, ALL_PROXY=proxy, NO_PROXY="")
  332. else:
  333. env.update(NO_PROXY="*", no_proxy="*")
  334. return env
  335. def test(provider=None):
  336. import httpx
  337. ctx = _context.get()
  338. proxy = route(_auth_urls.get(provider, "https://example.com/"))
  339. result = {"proxy": "skipped", "target": "skipped", "message": ""}
  340. if proxy and proxy != "environment":
  341. url = urlsplit(proxy)
  342. try:
  343. with socket.create_connection((url.hostname, url.port), timeout=5):
  344. pass
  345. result["proxy"] = "passed"
  346. except OSError:
  347. return {**result, "proxy": "failed", "message": "服务器无法连接代理,请检查地址、端口和代理是否运行。"}
  348. if not provider:
  349. return {**result, "message": "代理端口可达。请选择模型连接,继续测试目标服务。" if result["proxy"] == "passed" else "未指定代理,无需测试代理端口。"}
  350. url = _auth_urls.get(provider) or next((base for base, pid in ctx["routes"] if pid == provider), None)
  351. if not url:
  352. return {**result, "message": "该连接没有可测试的服务地址。"}
  353. try:
  354. with httpx.Client(timeout=10, follow_redirects=False) as client:
  355. with client.stream("GET", url) as response:
  356. status = response.status_code
  357. # An authorization-required response still proves the TLS target was reached.
  358. if status == 407:
  359. return {**result, "proxy": "failed", "message": "代理拒绝认证,请检查代理账号和密码。"}
  360. return {**result, "target": "passed", "message": "目标服务可达;这不代表账号已登录。"}
  361. except httpx.ProxyError:
  362. return {**result, "proxy": "failed", "target": "skipped", "message": "代理连接或认证失败,请检查代理协议、账号和密码。"}
  363. except Exception:
  364. return {**result, "target": "failed", "message": "目标服务不可达,请检查代理认证、出口网络或稍后重试。"}