Gateway-owned sessions (in-process turns and managed workers alike) got the runner's prefill examples, loaded once when the daemon started from the launch profile: a prefill_messages_file path or file edited after that never reached a new session. On pre-merge main every `hermes chat` process read the file once at startup from its own profile. session_prefill() resolves the path from the session policy's creation-time config, relative to the session's own profile home. The file is read by the creation attempt's commit (commit_local_session), before its write transaction; on the async create paths that runs in tracked_write's worker thread, not on the owner's event loop. The snapshot is carried with that creation attempt. It is held in the owning authority's memory only when that attempt's commit creates the session. An overlapping retry or a conflicting create never replaces it, and a refused or failed create (for example a retry of a deleted session) holds nothing. Other sessions cannot evict it, an edit after creation reaches only new sessions, and deleting the session releases it. A session this owner did not create (restored after a gateway restart, or a new branch) reads the file once on first use and keeps it; main's CLI likewise re-read it on every start. The in-process agent build and construct_inputs for managed workers share the snapshot, so both send the same examples. Bypass sessions still never load the profile's file. The HERMES_PREFILL_MESSAGES_FILE env precedence is unchanged. Related open PR, not used: #124630 (re-reads the active profile on every agent build for multiplexed messaging turns, against the pre-split layout; does not read the session's frozen config). Refs #134889 (CFG-7) Refs #139523
239 lines
13 KiB
Python
239 lines
13 KiB
Python
"""Managed execution gets the same owner-resolved agent-construction inputs as the in-process
|
|
turn (``construct_v1``): the configured fallback chain (andrexibiza N3) and the configured
|
|
instruction + prefill examples (andrexibiza N4).
|
|
|
|
One ordinary daemon, two sessions: in-process and ``gateway.managed_workers``. The loopback
|
|
primary refuses with 429 ``insufficient_quota``; a healthy loopback backup is configured in
|
|
``fallback_providers``. Both turns must reach the backup and complete.
|
|
"""
|
|
import asyncio
|
|
from contextlib import closing
|
|
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import sqlite3
|
|
import threading
|
|
from types import SimpleNamespace
|
|
|
|
import pytest
|
|
|
|
from tests.gateway.fixtures.local_recovery_probe import child_env, daemon, rpc, websocket
|
|
from tests.waiting import async_wait_until
|
|
|
|
|
|
def _reply(handler, body, text):
|
|
choice = {'index': 0, 'delta': {'role': 'assistant', 'content': text}, 'finish_reason': 'stop'}
|
|
frame = {'id': 'c', 'model': body.get('model'), 'choices': [choice],
|
|
'usage': {'prompt_tokens': 1, 'completion_tokens': 1, 'total_tokens': 2}}
|
|
if body.get('stream'):
|
|
payload, kind = ('data: ' + json.dumps(frame) + '\n\ndata: [DONE]\n\n').encode(), 'text/event-stream'
|
|
else:
|
|
choice['message'] = choice.pop('delta')
|
|
payload, kind = json.dumps(frame).encode(), 'application/json'
|
|
handler.send_response(200)
|
|
handler.send_header('Content-Type', kind)
|
|
handler.send_header('Content-Length', str(len(payload)))
|
|
handler.end_headers()
|
|
handler.wfile.write(payload)
|
|
|
|
|
|
class Primary(BaseHTTPRequestHandler):
|
|
def log_message(self, *args):
|
|
pass
|
|
|
|
def do_POST(self):
|
|
body = json.loads(self.rfile.read(int(self.headers['Content-Length'])))
|
|
if not body.get('messages'):
|
|
return _reply(self, body, 'meta')
|
|
self.server.requests.append(body)
|
|
if self.server.refuse:
|
|
data = json.dumps({'error': {'message': 'You exceeded your current quota', 'type': 'insufficient_quota',
|
|
'code': 'insufficient_quota'}}).encode()
|
|
self.send_response(429)
|
|
self.send_header('Content-Type', 'application/json')
|
|
self.send_header('Content-Length', str(len(data)))
|
|
self.end_headers()
|
|
self.wfile.write(data)
|
|
return
|
|
_reply(self, body, 'PRIMARY_OK')
|
|
|
|
|
|
class Backup(Primary):
|
|
def do_POST(self):
|
|
body = json.loads(self.rfile.read(int(self.headers['Content-Length'])))
|
|
if body.get('messages'):
|
|
self.server.requests.append(body)
|
|
_reply(self, body, 'BACKUP_OK')
|
|
|
|
|
|
def _serve(cls):
|
|
server = ThreadingHTTPServer(('127.0.0.1', 0), cls)
|
|
server.requests, server.refuse = [], False
|
|
threading.Thread(target=server.serve_forever, daemon=True).start()
|
|
return server
|
|
|
|
|
|
def run_pair(tmp_path, extra_config, turn, *, before_create=None, **create_params):
|
|
"""Boot one ordinary daemon; create an in-process and a managed session from the same config;
|
|
run ``turn(ws, sid, name, settle, servers)`` for each and return its results by session.
|
|
``before_create(home)`` edits the profile after the daemon started, before each create."""
|
|
root = Path(__file__).resolve().parents[2]
|
|
home, user = tmp_path / 'state', tmp_path / 'user'
|
|
home.mkdir(mode=0o700)
|
|
user.mkdir()
|
|
primary, backup = _serve(Primary), _serve(Backup)
|
|
purl, burl = (f'http://127.0.0.1:{s.server_port}/v1' for s in (primary, backup))
|
|
config = {'gateway': {'multiplex_profiles': False, 'managed_workers': False},
|
|
'model': {'provider': 'custom', 'default': 'primary-model', 'base_url': purl},
|
|
'auxiliary': {'title_generation': {'enabled': False}}, 'platform_toolsets': {'cli': []},
|
|
'fallback_providers': [{'provider': 'custom', 'model': 'backup-model', 'base_url': burl,
|
|
'api_key': 'loopback-only'}], **extra_config(home)}
|
|
(home / 'config.yaml').write_text(json.dumps(config))
|
|
env = {**child_env(), **{k: os.environ[k] for k in ('TIRITH_ENABLED',) if k in os.environ}}
|
|
env.update(HOME=str(user), USERPROFILE=str(user), HERMES_HOME=str(home), PYTHONPATH=str(root),
|
|
OPENAI_API_KEY='loopback-only', OPENAI_BASE_URL=purl)
|
|
|
|
def query(sql, args=()):
|
|
with closing(sqlite3.connect(f'file:{home / "state.db"}?mode=ro', uri=True)) as db:
|
|
return db.execute(sql, args).fetchall()
|
|
|
|
async def settle(ws, sid, request_id, text):
|
|
submitted = await rpc(ws, 'prompt.submit', session_id=sid, input_id=request_id, text=text)
|
|
assert 'result' in submitted, submitted
|
|
await async_wait_until(
|
|
lambda: query('SELECT status FROM session_admissions WHERE request_id=?', (request_id,)) == [('terminal',)],
|
|
timeout=120, interval=.05, what=f'admission {request_id} terminal')
|
|
[(admission,)] = query('SELECT admission_id FROM session_admissions WHERE request_id=?', (request_id,))
|
|
receipt = await rpc(ws, 'prompt.receipt', session_id=sid, admission_id=admission, include_result=True)
|
|
return receipt['result']['result']
|
|
|
|
results = {}
|
|
|
|
async def exercise(desc):
|
|
async with websocket(home, desc) as ws:
|
|
for name in ('inproc', 'managed'):
|
|
if before_create is not None:
|
|
before_create(home)
|
|
if name == 'managed':
|
|
edited = json.loads((home / 'config.yaml').read_text())
|
|
edited['gateway']['managed_workers'] = True
|
|
(home / 'config.yaml').write_text(json.dumps(edited))
|
|
created = await rpc(ws, 'session.create', request_id=name, source='cli', cwd=str(home),
|
|
model='primary-model', provider='custom', base_url=purl,
|
|
api_key='loopback-only', toolsets=[], **create_params)
|
|
assert 'result' in created, created
|
|
sid = created['result']['session_id']
|
|
results[name] = await turn(ws, sid, name, settle, SimpleNamespace(primary=primary, backup=backup, query=query))
|
|
results[name]['workers'] = query('SELECT COUNT(*) FROM worker_executions WHERE session_id=?', (sid,))[0][0]
|
|
try:
|
|
with daemon(root, home, env, barrier=False) as (_owner, desc):
|
|
asyncio.run(exercise(desc))
|
|
finally:
|
|
for server in (primary, backup):
|
|
server.shutdown()
|
|
server.server_close()
|
|
return results
|
|
|
|
|
|
@pytest.mark.platforms("linux")
|
|
def test_managed_turn_falls_back_like_the_in_process_turn(tmp_path):
|
|
async def turn(ws, sid, name, settle, servers):
|
|
servers.primary.refuse = True
|
|
start = len(servers.backup.requests)
|
|
result = await settle(ws, sid, name + '-refused', 'NEED_FALLBACK')
|
|
return {'result': {k: result.get(k) for k in ('final_response', 'failed', 'completed', 'model')},
|
|
'backup_models': {r.get('model') for r in servers.backup.requests[start:]}}
|
|
results = run_pair(tmp_path, lambda home: {}, turn)
|
|
expected = {'final_response': 'BACKUP_OK', 'failed': False, 'completed': True, 'model': 'backup-model'}
|
|
for name in ('inproc', 'managed'):
|
|
assert results[name]['result'] == expected, (name, results)
|
|
assert results[name]['backup_models'] == {'backup-model'}, results
|
|
assert (results['inproc']['workers'], results['managed']['workers']) == (0, 1), results
|
|
|
|
|
|
@pytest.mark.platforms("linux")
|
|
def test_managed_turn_sends_configured_instruction_and_prefill(tmp_path):
|
|
"""``agent.system_prompt`` and ``prefill_messages_file`` reach the managed model request in
|
|
the same places as in process, and stay out of the persisted system prompt."""
|
|
def extra(home):
|
|
(home / 'prefill.json').write_text(json.dumps([{'role': 'user', 'content': 'PREFILL_Q_MARK'},
|
|
{'role': 'assistant', 'content': 'PREFILL_A_MARK'}]))
|
|
return {'agent': {'system_prompt': 'SYS_PROMPT_MARK'}, 'prefill_messages_file': str(home / 'prefill.json')}
|
|
|
|
async def turn(ws, sid, name, settle, servers):
|
|
start = len(servers.primary.requests)
|
|
assert (await settle(ws, sid, name + '-plain', 'PLAIN_TURN'))['final_response'] == 'PRIMARY_OK'
|
|
[request] = servers.primary.requests[start:]
|
|
system = [m['content'] for m in request['messages'] if m['role'] == 'system']
|
|
prefill = [m['content'] for m in request['messages'] if 'PREFILL_' in str(m.get('content'))]
|
|
[(stored,)] = servers.query('SELECT p.prompt FROM sessions s JOIN system_prompts p '
|
|
'ON p.hash = s.system_prompt_hash WHERE s.id=?', (sid,))
|
|
return {'system_mark': [('SYS_PROMPT_MARK' in s) for s in system], 'prefill': prefill,
|
|
'stored': 'SYS_PROMPT_MARK' in stored}
|
|
results = run_pair(tmp_path, extra, turn)
|
|
for name in ('inproc', 'managed'):
|
|
found = {k: results[name][k] for k in ('system_mark', 'prefill', 'stored')}
|
|
assert found == {'system_mark': [True], 'prefill': ['PREFILL_Q_MARK', 'PREFILL_A_MARK'], 'stored': False}, (name, results)
|
|
|
|
|
|
@pytest.mark.platforms("linux")
|
|
def test_new_sessions_send_the_profiles_current_prefill(tmp_path):
|
|
"""CFG-7: a ``prefill_messages_file`` path and contents edited after the daemon started reach the
|
|
next new session, in process and managed, as a new ``hermes chat`` process read them on main."""
|
|
def pair(home, name, mark):
|
|
(home / name).write_text(json.dumps([{'role': 'user', 'content': f'PREFILL_{mark}_Q'},
|
|
{'role': 'assistant', 'content': f'PREFILL_{mark}_A'}]))
|
|
|
|
def extra(home):
|
|
pair(home, 'boot.json', 'BOOT')
|
|
return {'prefill_messages_file': 'boot.json'}
|
|
|
|
def edit(home):
|
|
pair(home, 'edited.json', 'EDITED')
|
|
config = json.loads((home / 'config.yaml').read_text())
|
|
config['prefill_messages_file'] = 'edited.json'
|
|
(home / 'config.yaml').write_text(json.dumps(config))
|
|
|
|
async def turn(ws, sid, name, settle, servers):
|
|
start = len(servers.primary.requests)
|
|
assert (await settle(ws, sid, name + '-plain', 'PLAIN_TURN'))['final_response'] == 'PRIMARY_OK'
|
|
[request] = servers.primary.requests[start:]
|
|
return {'prefill': [m['content'] for m in request['messages'] if 'PREFILL_' in str(m.get('content'))]}
|
|
results = run_pair(tmp_path, extra, turn, before_create=edit)
|
|
for name in ('inproc', 'managed'):
|
|
assert results[name]['prefill'] == ['PREFILL_EDITED_Q', 'PREFILL_EDITED_A'], (name, results)
|
|
|
|
|
|
def test_construct_inputs_follow_the_session_mode(tmp_path, monkeypatch):
|
|
"""Ordinary: the owner's per-turn profile refresh, configured prompt and the session's own prefill
|
|
(none configured here; never the runner's daemon-start copy); config-only:
|
|
the frozen snapshot's chain and launch skills only, never the profile; safe mode: nothing.
|
|
The child accepts only the closed shape."""
|
|
from gateway.session_local import _bypass_policy
|
|
from gateway.session_policy import build_policy
|
|
from gateway.session_worker_construct import construct_inputs, construct_kwargs
|
|
chain = [{'provider': 'custom', 'model': 'b', 'base_url': 'http://127.0.0.1:9/v1'}]
|
|
profile_reads = []
|
|
runner = SimpleNamespace(config=None, _prefill_messages=[{'role': 'user', 'content': 'P'}],
|
|
_refresh_fallback_model=lambda: profile_reads.append('fallback') or chain,
|
|
_get_system_prompt_for_channel=lambda *a: profile_reads.append('prompt') or 'SYS')
|
|
authority = SimpleNamespace(runner=runner, profile_id=str(tmp_path))
|
|
launch = {'cwd': str(tmp_path), 'model': 'm', 'provider': 'custom', 'base_url': 'http://127.0.0.1:9/v1'}
|
|
ordinary = build_policy(launch, {})
|
|
config_only = _bypass_policy({**launch, 'ignore_user_config': True}, private_secrets={})
|
|
safe = _bypass_policy({**launch, 'safe_mode': True}, private_secrets={})
|
|
assert construct_inputs(authority, ordinary, 'c') == {
|
|
'fallback_model': chain, 'ephemeral_system_prompt': 'SYS', 'prefill_messages': None}
|
|
assert profile_reads == ['fallback', 'prompt']
|
|
empty = {'fallback_model': None, 'ephemeral_system_prompt': None, 'prefill_messages': None}
|
|
assert construct_inputs(authority, config_only, 'c') == empty
|
|
assert construct_inputs(authority, safe, 'c') == empty and profile_reads == ['fallback', 'prompt']
|
|
frame = {'policy': {'request_json': json.dumps({'construct_v1': construct_inputs(authority, ordinary, 'c')})}}
|
|
assert construct_kwargs(frame)['fallback_model'] == chain
|
|
assert construct_kwargs({'policy': {'request_json': '{}'}}) == {}
|
|
for bad in ({**empty, 'fallback_model': 'x'}, {**empty, 'extra': 1}, {**empty, 'ephemeral_system_prompt': 1},
|
|
{**empty, 'prefill_messages': ['x']}, []):
|
|
with pytest.raises(ValueError):
|
|
construct_kwargs({'policy': {'request_json': json.dumps({'construct_v1': bad})}})
|