test_hermes_service.py 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435
  1. """Hermes provider/auth bridge: every op lands in Hermes-native config.yaml/.env/auth.json."""
  2. import json
  3. import os
  4. import queue
  5. import stat
  6. import subprocess
  7. import sys
  8. import tempfile
  9. import threading
  10. import unittest
  11. from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
  12. from pathlib import Path
  13. ROOT = Path(__file__).resolve().parents[2]
  14. class Service:
  15. def __init__(self, home, root=None, extra_env=None):
  16. env = {"PATH": os.environ.get("PATH", ""), "HOME": str(home), "HERMES_HOME": str(home), "YAOVI_KERNEL": "1",
  17. "PYTHONUNBUFFERED": "1", "HERMES_SKIP_UPDATE_CHECK": "1",
  18. "YAOVI_HERMES_TEST_OFFLINE": "1", **(extra_env or {})}
  19. if root:
  20. env["YAOVI_HERMES_ROOT"] = str(root)
  21. self.proc = subprocess.Popen([sys.executable, str(ROOT / "runtime" / "hermes_service.py")], cwd=ROOT / "runtime",
  22. env=env, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True)
  23. assert json.loads(self.proc.stdout.readline())["type"] == "ready"
  24. self.n = 0
  25. def call(self, op, **args):
  26. self.n += 1
  27. self.proc.stdin.write(json.dumps({"id": str(self.n), "op": op, "args": args}) + "\n")
  28. self.proc.stdin.flush()
  29. return json.loads(self.proc.stdout.readline())
  30. def close(self):
  31. self.proc.stdin.close()
  32. self.proc.wait(timeout=10)
  33. self.proc.stdout.close()
  34. class HermesServiceTest(unittest.TestCase):
  35. def setUp(self):
  36. self.tmp = tempfile.TemporaryDirectory()
  37. self.root = Path(self.tmp.name) / "hermes"
  38. self.bot = Path(self.tmp.name) / "bots" / "b1" / "runtime"
  39. self.root.mkdir(parents=True)
  40. self.bot.mkdir(parents=True)
  41. def tearDown(self):
  42. self.tmp.cleanup()
  43. def test_bot_home_reads_system_root_as_profile_parent(self):
  44. s = Service(self.bot, self.root)
  45. try:
  46. r = s.call("ping")
  47. self.assertEqual(Path(r["result"]["home"]).resolve(), self.bot.resolve())
  48. self.assertEqual(Path(r["result"]["root"]).resolve(), self.root.resolve())
  49. finally:
  50. s.close()
  51. def test_oauth_completion_preserves_the_selected_provider_and_model(self):
  52. code = '''
  53. import sys
  54. from pathlib import Path
  55. sys.path[:0]=[str(Path.cwd()/"runtime"),str(Path.cwd()/"runtime/hermes")]
  56. import hermes_service
  57. hermes_service._bootstrap()
  58. from hermes_cli.config import save_config,read_raw_config
  59. from hermes_cli import anon_auth
  60. for model in ({"provider":"openai-codex","default":"user-choice"},{"provider":"nous","default":"nous/welcome","base_url":"https://welcome.nousresearch.com/v1"}):
  61. save_config({"model":model})
  62. before=Path(__import__("os").environ["HERMES_HOME"],"config.yaml").read_bytes()
  63. result=anon_auth.settle_after_upgrade({"inference_base_url":"https://new-account.example/v1"})
  64. assert result=={"model":model["default"],"changed":False},result
  65. assert Path(__import__("os").environ["HERMES_HOME"],"config.yaml").read_bytes()==before
  66. '''
  67. result = subprocess.run([sys.executable, "-c", code], cwd=ROOT,
  68. env={"PATH": os.environ.get("PATH", ""), "HOME": str(self.root), "HERMES_HOME": str(self.root),
  69. "YAOVI_KERNEL": "1", "YAOVI_HERMES_TEST_OFFLINE": "1", "HERMES_SKIP_UPDATE_CHECK": "1"},
  70. capture_output=True, text=True, timeout=30)
  71. self.assertEqual(result.returncode, 0, result.stderr[-4000:])
  72. def test_nous_credential_save_preserves_active_provider_and_explicit_model_changes(self):
  73. code = '''
  74. import json,os,sys
  75. from pathlib import Path
  76. from unittest.mock import patch
  77. sys.path[:0]=[str(Path.cwd()/"runtime"),str(Path.cwd()/"runtime/hermes")]
  78. import hermes_service
  79. hermes_service._bootstrap()
  80. from hermes_cli import auth,anon_auth
  81. from hermes_cli.auth_nous import persist_nous_credentials
  82. from hermes_cli.config import save_config,read_raw_config
  83. home=Path(os.environ["HERMES_HOME"])
  84. # Exercise the actual credential writer used by both the plain OAuth poller and
  85. # guest promotion, including native pool reseeding. Only shared-store mirroring
  86. # is isolated, so the test cannot reach a user-global credential file.
  87. with patch("hermes_cli.auth._write_shared_nous_state"):
  88. for active in ("openai-codex","nous",None):
  89. original={"providers":{"openai-codex":{"access_token":"fixture-existing"}}}
  90. if active is not None: original["active_provider"]=active
  91. home.joinpath("auth.json").write_text(json.dumps(original))
  92. model={"provider":"auto","default":"user-choice","base_url":"https://chosen.example/v1"}
  93. save_config({"model":model})
  94. before=home.joinpath("config.yaml").read_bytes()
  95. persist_nous_credentials({"access_token":"fixture-new","token_type":"Bearer"},label="Connected apps")
  96. anon_auth.settle_after_upgrade({"inference_base_url":"https://new-account.example/v1"})
  97. stored=json.loads(home.joinpath("auth.json").read_text())
  98. assert stored.get("active_provider")==active,stored
  99. assert ("active_provider" in stored)==(active is not None),stored
  100. assert stored["providers"]["nous"]["access_token"]=="fixture-new"
  101. assert stored["providers"]["openai-codex"]["access_token"]=="fixture-existing"
  102. assert home.joinpath("config.yaml").read_bytes()==before
  103. # A user choosing a new default still updates both stores, and a later
  104. # credential save merges into that current state instead of restoring a stale one.
  105. save_config({"model":{"default":"vendor/old-model"}})
  106. auth._update_config_for_provider("openai-codex","",default_model="explicit-new-model")
  107. persist_nous_credentials({"access_token":"fixture-refreshed","token_type":"Bearer"})
  108. assert auth.get_active_provider()=="openai-codex"
  109. assert read_raw_config()["model"]["default"]=="explicit-new-model"
  110. assert read_raw_config()["model"]["provider"]=="openai-codex"
  111. save_config({"model":{"default":"vendor/old-model"}})
  112. auth._update_config_for_provider("nous","https://chosen.example/v1",default_model="explicit-nous-model")
  113. assert auth.get_active_provider()=="nous"
  114. assert read_raw_config()["model"]["default"]=="explicit-nous-model"
  115. '''
  116. result = subprocess.run([sys.executable, "-c", code], cwd=ROOT,
  117. env={"PATH": os.environ.get("PATH", ""), "HOME": str(self.root), "HERMES_HOME": str(self.root),
  118. "YAOVI_KERNEL": "1", "YAOVI_HERMES_TEST_OFFLINE": "1", "HERMES_SKIP_UPDATE_CHECK": "1"},
  119. capture_output=True, text=True, timeout=30)
  120. self.assertEqual(result.returncode, 0, result.stderr[-4000:])
  121. def test_config_patch_is_validated_and_hermes_native(self):
  122. s = Service(self.root)
  123. try:
  124. ok = s.call("config.patch", config={"model": {"provider": "deepseek", "default": "deepseek-chat"},
  125. "fallback_model": [{"provider": "openrouter", "model": "anthropic/claude-sonnet-4"}],
  126. "auxiliary": {"vision": {"provider": "auto", "model": ""}}})
  127. self.assertTrue(ok["ok"], ok)
  128. text = (self.root / "config.yaml").read_text()
  129. self.assertIn("deepseek-chat", text)
  130. self.assertIn("fallback_model", text)
  131. bad = s.call("config.patch", config={"fallback_model": "nope"})
  132. self.assertFalse(bad["ok"])
  133. self.assertEqual(bad["status"], 400)
  134. rejected = s.call("config.patch", config={"terminal": {}})
  135. self.assertEqual(rejected["status"], 400)
  136. finally:
  137. s.close()
  138. def test_persisted_config_reads_finish_while_auxiliary_request_is_still_running(self):
  139. entered, release = threading.Event(), threading.Event()
  140. class SlowModel(BaseHTTPRequestHandler):
  141. def log_message(self, *args):
  142. pass
  143. def do_POST(self):
  144. self.rfile.read(int(self.headers["Content-Length"]))
  145. entered.set()
  146. release.wait(10)
  147. data = json.dumps({"choices": [{"message": {"content": "done"}, "finish_reason": "stop"}]}).encode()
  148. self.send_response(200)
  149. self.send_header("Content-Type", "application/json")
  150. self.send_header("Content-Length", str(len(data)))
  151. self.end_headers()
  152. self.wfile.write(data)
  153. server = ThreadingHTTPServer(("127.0.0.1", 0), SlowModel)
  154. threading.Thread(target=server.serve_forever, daemon=True).start()
  155. self.addCleanup(server.server_close)
  156. self.addCleanup(server.shutdown)
  157. s = Service(self.root)
  158. responses = queue.Queue()
  159. reader = None
  160. persisted = {"model": {"provider": "system", "default": "system-model"},
  161. "custom_providers": [{"name": "system", "api_key": "fixture-system-secret", "base_url": "http://127.0.0.1:1/v1"}]}
  162. try:
  163. self.assertTrue(s.call("config.patch", config=persisted)["ok"])
  164. before = (self.root / "config.yaml").read_bytes()
  165. def read_responses():
  166. for line in s.proc.stdout:
  167. responses.put(json.loads(line))
  168. reader = threading.Thread(target=read_responses, daemon=True)
  169. reader.start()
  170. def send(rid, op, **args):
  171. s.proc.stdin.write(json.dumps({"id": rid, "op": op, "args": args}) + "\n")
  172. s.proc.stdin.flush()
  173. overlay = {"model": {"provider": "slow", "default": "bot-model"},
  174. "custom_providers": [{"name": "slow", "base_url": f"http://127.0.0.1:{server.server_port}/v1",
  175. "api_key": "fixture-bot-secret", "api_mode": "chat_completions"}]}
  176. send("slow", "aux.complete", prompt="synthetic request", config=overlay, timeout=5)
  177. self.assertTrue(entered.wait(5), "auxiliary request did not reach the gated model")
  178. for op in ("config.compiled", "config.get"):
  179. send(op, op)
  180. response = responses.get(timeout=2)
  181. self.assertEqual(response["id"], op)
  182. self.assertTrue(response["ok"], response)
  183. config = response["result"]["config"]
  184. self.assertEqual(config["model"], persisted["model"])
  185. self.assertNotIn("fixture-bot-secret", json.dumps(config))
  186. self.assertNotIn("bot-model", json.dumps(config))
  187. if op == "config.compiled":
  188. self.assertEqual(config, persisted)
  189. else:
  190. self.assertNotIn("fixture-system-secret", json.dumps(config))
  191. self.assertFalse(release.is_set())
  192. self.assertEqual((self.root / "config.yaml").read_bytes(), before)
  193. release.set()
  194. completed = responses.get(timeout=5)
  195. self.assertEqual(completed["id"], "slow")
  196. self.assertTrue(completed["ok"], completed)
  197. send("after", "config.compiled")
  198. self.assertEqual(responses.get(timeout=2)["result"]["config"], persisted)
  199. finally:
  200. release.set()
  201. s.close()
  202. if reader:
  203. reader.join(2)
  204. def test_credential_pool_is_plaintext_0600_and_redacted_on_wire(self):
  205. s = Service(self.root)
  206. try:
  207. added = s.call("pool.add", provider="deepseek", apiKey="sk-secret-abcdef123456", label="main")
  208. self.assertTrue(added["ok"], added)
  209. listed = s.call("pool.list", provider="deepseek")
  210. self.assertNotIn("sk-secret", json.dumps(listed))
  211. self.assertEqual(listed["result"]["entries"][0]["tokenPreview"], "…3456")
  212. auth = self.root / "auth.json"
  213. self.assertIn("sk-secret-abcdef123456", auth.read_text())
  214. self.assertEqual(stat.S_IMODE(auth.stat().st_mode), 0o600)
  215. self.assertTrue(s.call("pool.remove", provider="deepseek", index=1)["ok"])
  216. self.assertEqual(s.call("pool.list", provider="deepseek")["result"]["entries"], [])
  217. finally:
  218. s.close()
  219. def test_native_media_catalog_selection_and_key_validation(self):
  220. s = Service(self.root)
  221. try:
  222. for name, provider in (("image_gen", "OpenAI"), ("video_gen", "xAI Grok Imagine")):
  223. config = s.call("media.config", name=name)
  224. self.assertTrue(config["ok"], config)
  225. self.assertIn(provider, {p["name"] for p in config["result"]["providers"]})
  226. models = s.call("media.models", name=name, provider=provider)["result"]
  227. self.assertTrue(models["models"])
  228. model = models["models"][0]["id"]
  229. self.assertTrue(s.call("media.provider", name=name, provider=provider)["ok"])
  230. self.assertTrue(s.call("media.model", name=name, provider=provider, model=model)["ok"])
  231. raw = s.call("config.get")["result"]["config"]
  232. self.assertIn(model, (self.root / "config.yaml").read_text())
  233. self.assertEqual(raw[name]["provider"], "openai" if name == "image_gen" else "xai")
  234. self.assertEqual(raw[name]["model"], model)
  235. self.assertEqual(s.call("config.compiled")["result"]["config"][name], raw[name])
  236. self.assertEqual(s.call("media.model", name=name, provider=provider, model="not-a-model")["status"], 400)
  237. self.assertTrue(s.call("media.env", name="image_gen", env={"OPENAI_API_KEY": "sk-media-native-secret"})["ok"])
  238. self.assertIn("sk-media-native-secret", (self.root / ".env").read_text())
  239. self.assertNotIn("sk-media-native-secret", json.dumps(s.call("media.config", name="image_gen")))
  240. self.assertEqual(s.call("media.env", name="image_gen", env={"PATH": "nope"})["status"], 400)
  241. self.assertEqual(s.call("media.provider", name="video_gen", provider="OpenAI")["status"], 400)
  242. finally:
  243. s.close()
  244. def test_native_openai_image_dispatch_uses_media_settings_not_the_chat_model(self):
  245. import base64
  246. png = base64.b64decode("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIHWP4z8DwHwAFgAI/ScLttAAAAABJRU5ErkJggg==")
  247. seen = []
  248. class Images(BaseHTTPRequestHandler):
  249. def log_message(self, *a):
  250. pass
  251. def do_POST(self):
  252. body = json.loads(self.rfile.read(int(self.headers["Content-Length"])))
  253. seen.append((self.path, body, self.headers.get("Authorization")))
  254. data = json.dumps({"created": 1, "data": [{"b64_json": base64.b64encode(png).decode()}]}).encode()
  255. self.send_response(200)
  256. self.send_header("Content-Type", "application/json")
  257. self.send_header("Content-Length", str(len(data)))
  258. self.end_headers()
  259. self.wfile.write(data)
  260. server = ThreadingHTTPServer(("127.0.0.1", 0), Images)
  261. threading.Thread(target=server.serve_forever, daemon=True).start()
  262. self.addCleanup(server.server_close)
  263. self.addCleanup(server.shutdown)
  264. s = Service(self.root)
  265. try:
  266. self.assertTrue(s.call("env.set", key="OPENAI_API_KEY", value="native-image-key")["ok"])
  267. self.assertTrue(s.call("env.set", key="OPENAI_BASE_URL", value=f"http://127.0.0.1:{server.server_port}/v1")["ok"])
  268. self.assertTrue(s.call("media.provider", name="image_gen", provider="OpenAI")["ok"])
  269. models = s.call("media.models", name="image_gen", provider="OpenAI")["result"]
  270. chosen = models["models"][0]["id"]
  271. self.assertTrue(s.call("media.model", name="image_gen", provider="OpenAI", model=chosen)["ok"])
  272. result = s.call("media.generate", name="image_gen", arguments={"prompt": "a tree", "aspect_ratio": "square"})
  273. self.assertTrue(result["ok"], result)
  274. self.assertEqual(base64.b64decode(result["result"]["data"]), png)
  275. self.assertEqual(result["result"]["mimeType"], "image/png")
  276. self.assertEqual(seen[0][0], "/v1/images/generations")
  277. self.assertTrue(seen[0][1]["model"].startswith("gpt-image"))
  278. self.assertEqual(seen[0][2], "Bearer native-image-key")
  279. finally:
  280. s.close()
  281. def test_native_video_dispatch_downloads_the_completed_provider_job(self):
  282. import base64
  283. video = b"\x00\x00\x00\x18ftypmp42native-video-fixture"
  284. seen = []
  285. class Videos(BaseHTTPRequestHandler):
  286. def log_message(self, *a):
  287. pass
  288. def do_POST(self):
  289. body = json.loads(self.rfile.read(int(self.headers["Content-Length"])))
  290. seen.append((self.path, body, self.headers.get("Authorization")))
  291. data = json.dumps({"id": "native-job", "status": "completed", "model": body["model"],
  292. "object": "video", "created_at": 1, "seconds": "5", "size": "1280x720"}).encode()
  293. self.send_response(200)
  294. self.send_header("Content-Type", "application/json")
  295. self.send_header("Content-Length", str(len(data)))
  296. self.end_headers()
  297. self.wfile.write(data)
  298. def do_GET(self):
  299. seen.append((self.path, None, self.headers.get("Authorization")))
  300. self.send_response(200)
  301. self.send_header("Content-Type", "video/mp4")
  302. self.send_header("Content-Length", str(len(video)))
  303. self.end_headers()
  304. self.wfile.write(video)
  305. server = ThreadingHTTPServer(("127.0.0.1", 0), Videos)
  306. threading.Thread(target=server.serve_forever, daemon=True).start()
  307. self.addCleanup(server.server_close)
  308. self.addCleanup(server.shutdown)
  309. s = Service(self.root)
  310. try:
  311. s.call("env.set", key="DEEPINFRA_API_KEY", value="native-video-key")
  312. s.call("env.set", key="DEEPINFRA_BASE_URL", value=f"http://127.0.0.1:{server.server_port}/v1")
  313. # Dynamic provider catalogs need the remote API; this offline fixture supplies its native config directly.
  314. self.assertTrue(s.call("config.patch", config={"video_gen": {"provider": "deepinfra", "model": "native-video"}})["ok"])
  315. result = s.call("media.generate", name="video_gen", arguments={"prompt": "a moving tree", "duration": 5})
  316. self.assertTrue(result["ok"], result)
  317. self.assertEqual(result["result"]["mimeType"], "video/mp4")
  318. self.assertEqual(base64.b64decode(result["result"]["data"]), video)
  319. self.assertEqual(seen[0][0], "/v1/videos")
  320. self.assertEqual(seen[0][1]["model"], "native-video")
  321. self.assertEqual(seen[0][2], "Bearer native-video-key")
  322. self.assertEqual(seen[1][0], "/v1/videos/native-job/content")
  323. finally:
  324. s.close()
  325. def test_catalog_has_full_hermes_parity_and_oauth_external_is_refused(self):
  326. s = Service(self.root)
  327. try:
  328. ids = {p["id"] for p in s.call("providers.catalog")["result"]["providers"]}
  329. sys.path.insert(0, str(ROOT / "runtime" / "hermes"))
  330. from hermes_cli.providers import HERMES_OVERLAYS
  331. self.assertTrue(set(HERMES_OVERLAYS) <= ids, set(HERMES_OVERLAYS) - ids)
  332. oauth = {p["id"]: p for p in s.call("oauth.list")["result"]["providers"]}
  333. self.assertEqual(oauth["openai-codex"]["flow"], "device_code")
  334. refused = s.call("oauth.start", provider="anthropic") # paste-token only, never in-app PKCE
  335. self.assertEqual(refused["status"], 400)
  336. offline = s.call("oauth.start", provider="qwen-oauth") # remote OAuth unreachable in tests
  337. self.assertEqual(offline["status"], 502)
  338. self.assertEqual(s.call("nope")["status"], 404)
  339. finally:
  340. s.close()
  341. def test_env_keys_go_to_dotenv(self):
  342. s = Service(self.root)
  343. try:
  344. r = s.call("env.set", key="DEEPSEEK_API_KEY", value="sk-env-0987654321")
  345. self.assertTrue(r["ok"], r)
  346. self.assertIn("DEEPSEEK_API_KEY", (self.root / ".env").read_text())
  347. listed = s.call("env.list")["result"]
  348. self.assertTrue(listed["DEEPSEEK_API_KEY"]["is_set"])
  349. self.assertNotIn("sk-env-0987654321", json.dumps(listed))
  350. finally:
  351. s.close()
  352. def test_aux_complete_routes_task_slot_through_compiled_config(self):
  353. seen = []
  354. class Model(BaseHTTPRequestHandler):
  355. def log_message(self, *a):
  356. pass
  357. def do_POST(self):
  358. body = json.loads(self.rfile.read(int(self.headers["Content-Length"])))
  359. seen.append({"path": self.path, "model": body.get("model"), "auth": self.headers.get("Authorization")})
  360. data = json.dumps({"id": "x", "object": "chat.completion", "model": body.get("model"),
  361. "choices": [{"index": 0, "message": {"role": "assistant", "content": "标题:测试"}, "finish_reason": "stop"}],
  362. "usage": {"prompt_tokens": 1, "completion_tokens": 1, "total_tokens": 2}}).encode()
  363. self.send_response(200)
  364. self.send_header("Content-Type", "application/json")
  365. self.send_header("Content-Length", str(len(data)))
  366. self.end_headers()
  367. self.wfile.write(data)
  368. server = ThreadingHTTPServer(("127.0.0.1", 0), Model)
  369. threading.Thread(target=server.serve_forever, daemon=True).start()
  370. self.addCleanup(server.server_close)
  371. self.addCleanup(server.shutdown)
  372. endpoint = f"http://127.0.0.1:{server.server_port}/v1"
  373. s = Service(self.bot, self.root)
  374. try:
  375. config = {"model": {"provider": "main", "default": "main-model"},
  376. "custom_providers": [{"name": "main", "base_url": endpoint, "api_key": "main-key", "api_mode": "chat_completions"},
  377. {"name": "cheap", "base_url": endpoint, "api_key": "cheap-key", "api_mode": "chat_completions"}],
  378. "auxiliary": {"title_generation": {"provider": "cheap", "model": "cheap-model"}}}
  379. r = s.call("aux.complete", task="title_generation", prompt="起个标题", config=config)
  380. self.assertTrue(r["ok"], r)
  381. self.assertEqual(r["result"]["text"], "标题:测试")
  382. self.assertEqual(seen[-1]["model"], "cheap-model")
  383. self.assertEqual(seen[-1]["auth"], "Bearer cheap-key")
  384. r = s.call("aux.complete", task="title_generation", prompt="synthetic observed title", config=config,
  385. usageObservation={"rootRunId":"synthetic-root", "role":"auxiliary"})
  386. self.assertTrue(r["ok"], r)
  387. observed = r['result']['usageObservations']
  388. self.assertEqual([e['status'] for e in observed], ['started', 'completed'])
  389. self.assertEqual(observed[-1]['role'], 'auxiliary')
  390. self.assertEqual(observed[-1]['inputTokens'], 1)
  391. self.assertEqual(r['result']['text'], '标题:测试')
  392. r = s.call("aux.complete", task="compression", prompt="压缩", config=config)
  393. self.assertTrue(r["ok"], r)
  394. self.assertEqual(seen[-1]["model"], "main-model")
  395. self.assertNotIn('usageObservations', r['result'])
  396. finally:
  397. s.close()
  398. if __name__ == "__main__":
  399. unittest.main()