Skip to content

A self-improving RLM agent for coding workflows and long-running autonomous tasks.

Rust
12.2 KB
Raw Blame
#!/usr/bin/env python3
"""Real-daemon #3602 half-close check, with an owned blocked provider.

Only fixture-created daemon trees are stopped. Provider arrival, not elapsed
sleep, proves the initial turn is busy and the queued prompt actually drains.
"""
import argparse
import json
import os
from pathlib import Path
import socket
import signal
import time
import subprocess
import tempfile
import threading

from check_agent_bounce import Client, Provider, Handler, LIMIT
from lifecycle_lib import digest, env_for, stop

FIRST = 'WRITE_CLEANUP_INITIAL_BUSY_TURN'
SECOND = 'WRITE_CLEANUP_QUEUED_SECOND_CLIENT'


class CompletionHandler(Handler):
    def do_POST(self):
        if self.path != '/v1/chat/completions':
            self.send_error(404)
            return
        body = json.loads(self.rfile.read(int(self.headers['Content-Length'])))
        with self.server.arrived:
            self.server.requests.append(body)
            self.server.arrived.notify_all()
        self.server.release.wait(LIMIT * 3)
        self.send_response(200)
        self.send_header('Content-Type', 'text/event-stream')
        self.end_headers()
        frames = [
            {'choices': [{'index': 0, 'delta': {'role': 'assistant',
                'content': 'Fixture turn completed.'}, 'finish_reason': None}]},
            {'choices': [{'index': 0, 'delta': {}, 'finish_reason': 'stop'}]},
        ]
        try:
            for frame in frames:
                self.wfile.write(('data: ' + json.dumps(frame) + '\n\n').encode())
            self.wfile.write(b'data: [DONE]\n\n')
            self.wfile.flush()
        except (BrokenPipeError, ConnectionResetError):
            pass


class RecordedIO:
    def __init__(self, inner, wire, direction):
        self.inner, self.wire, self.direction = inner, wire, direction

    def __getattr__(self, key):
        return getattr(self.inner, key)

    def sendall(self, data):
        self.wire.append({'direction': self.direction, 'utf8': data.decode()})
        return self.inner.sendall(data)

    def readline(self):
        data = self.inner.readline()
        self.wire.append({'direction': self.direction, 'utf8': data.decode()})
        return data


class WireClient(Client):
    def __init__(self, path, process):
        super().__init__(path, process)
        self.raw_wire = []
        self.sock = RecordedIO(self.sock, self.raw_wire, 'out')
        self.reader = RecordedIO(self.reader, self.raw_wire, 'in')
        self.closed = False

    def close(self):
        if not self.closed:
            super().close()
            self.closed = True


def owned_processes(root):
    """Linux hosted receipt: exact unique fixture agent-dir environment ownership."""
    expected = ('PRIME_AGENT_CODING_AGENT_DIR=' + str(root / 'agent')).encode()
    owned = []
    for directory in Path('/proc').iterdir():
        if directory.name.isdigit():
            try:
                if expected in (directory / 'environ').read_bytes().split(b'\0'):
                    owned.append(int(directory.name))
            except (FileNotFoundError, ProcessLookupError, PermissionError):
                pass
    return owned


def settle_owned_processes(root, observed):
    deadline = time.monotonic() + LIMIT
    while owned_processes(root) and time.monotonic() < deadline:
        threading.Event().wait(0.025)
    remaining = owned_processes(root)
    observed['remaining_owned_processes'] = remaining
    if remaining:
        # Failed cleanup never becomes a green receipt. Best-effort signals
        # recheck exact fixture ownership before touching each detached process.
        for sig in (signal.SIGTERM, signal.SIGKILL):
            for pid in owned_processes(root):
                try:
                    os.kill(pid, sig)
                except ProcessLookupError:
                    pass
        raise RuntimeError('owned fixture processes survived shutdown: ' + str(remaining))


def validate_rename_trigger(data, active):
    assert isinstance(data, dict), 'rename trigger omitted its session summary'
    assert data.get('activeSessionId') == active, 'rename summary changed session identity'
    assert data.get('sessionName') == 'Write cleanup fixture', 'rename summary has wrong name'
    assert isinstance(data.get('workerPid'), int), 'rename summary omitted worker identity'


def pause_released(client, active, pause_id):
    """A non-owner cannot release this lease; success means cleanup removed it."""
    try:
        client.call('release_session_input_pause', activeSessionId=active, pauseId=pause_id)
        return True
    except AssertionError:
        response = client.wire[-1]
        assert response.get('command') == 'release_session_input_pause' and response.get('success') is False, response
        assert response.get('error') == 'Session input pause is owned by another client: ' + pause_id, response
        return False


def run_case(binary, root, observed):
    env = env_for(root)
    provider = Provider()
    provider.RequestHandlerClass = CompletionHandler
    threading.Thread(target=provider.serve_forever, daemon=True).start()
    clients = []
    process = None
    log = None
    primary_error = None
    try:
        models = {'providers': {'parity-local': {'api': 'openai-completions',
            'apiKey': 'fixture-only', 'baseUrl': f'http://127.0.0.1:{provider.server_port}/v1',
            'models': [{'id': 'parity-1', 'name': 'Parity 1', 'reasoning': False,
                        'contextWindow': 128000, 'maxTokens': 4096}]}}}
        (root / 'agent/models.json').write_text(json.dumps(models))
        (root / 'agent/settings.json').write_text(json.dumps({'prewarmPythonKernel': False,
            'defaultProvider': 'parity-local', 'defaultModel': 'parity-1',
            'onboardingCompleted': True, 'telemetry': {'noticeShown': True}}))
        path = root / 'd.sock'
        log = open(root / 'daemon.log', 'wb')
        process = subprocess.Popen([str(binary), '--mode', 'daemon', '--daemon-socket', str(path)],
            cwd=root, env=env, stdout=log, stderr=subprocess.STDOUT, start_new_session=True)
        observer = WireClient(path, process)
        clients.append(observer)
        config = {'cwd': str(root), 'agentDir': str(root / 'agent'),
                  'provider': 'parity-local', 'model': 'parity-1',
                  'noExtensions': True, 'noSkills': True, 'noTools': True,
                  'noContextFiles': True, 'telemetryDisabled': True}
        created = observer.call('create', config=config)
        active = created.get('activeSessionId') or created.get('id')
        assert active, created
        a = WireClient(path, process)
        clients.append(a)
        a.call('attach', activeSessionId=active)
        responses = observed['action_responses'] = {}
        responses['start_busy_turn'] = a.call('prompt', activeSessionId=active, message=FIRST)
        provider.wait_for(FIRST)
        responses['acquire_pause'] = a.call('acquire_session_input_pause',
            activeSessionId=active, leaseKey='write-cleanup-gate')
        assert isinstance(responses['acquire_pause']['pauseId'], str), responses
        b = WireClient(path, process)
        clients.append(b)
        pause_id = responses['acquire_pause']['pauseId']
        before = b.call('get_state', activeSessionId=active)
        assert before['attachedClients'] == 1, before
        assert not pause_released(b, active, pause_id), 'pause was not held before disconnect'
        # A rename is a legal non-input action while a pause is held; it publishes
        # the attached event that must fail its write to A. A keeps its write half
        # open, so no read EOF can clean up.
        a.sock.shutdown(socket.SHUT_RD)
        trigger = observed['rename_trigger_response'] = b.call('set_session_name',
            activeSessionId=active, name='Write cleanup fixture')
        validate_rename_trigger(trigger, active)
        deadline = time.monotonic() + LIMIT
        observations = observed['disconnect_observations'] = []
        while True:
            state = b.call('get_state', activeSessionId=active)
            detached = state['attachedClients'] == 0
            released = pause_released(b, active, pause_id)
            observations.append({'attachedClients': state['attachedClients'], 'pause_released': released})
            if detached and released:
                break
            assert time.monotonic() < deadline, 'failed write did not detach A and release its pause'
            threading.Event().wait(0.025)
        responses['enqueue_second_client'] = b.call('prompt',
            activeSessionId=active, message=SECOND, streamingBehavior='followUp')
        observed['before_provider_release'] = b.call('get_queue', activeSessionId=active)
        queued = observed['before_provider_release']
        assert SECOND in queued['steering'] + queued['followUp'], queued
        provider.release.set()
        # This marker can only arrive if the dead client's held pause released;
        # a passing wait_for_idle alone could overlook a paused queued prompt.
        provider.wait_for(SECOND)
        responses['settle_second_client'] = b.call('wait_for_idle', activeSessionId=active)
        responses['queue_after_drain'] = b.call('get_queue', activeSessionId=active)
        assert responses['queue_after_drain'] == {'steering': [], 'followUp': []}, responses
        observed['action_responses'] = responses
        observed['hello'] = observer.hello
        observed['provider_requests'] = provider.requests
    except Exception as error:
        primary_error = error
        observed['primary_error'] = str(error)
        raise
    finally:
        cleanup_error = None
        provider.release.set()
        if process and process.poll() is None and clients:
            try:
                clients[0].call('shutdown', force=True)
                # The daemon's close waits for every fixture peer to close.
                # The SECOND provider-arrival proof already finished above.
                for client in clients:
                    client.close()
                process.wait(timeout=15)
                observed['shutdown'] = 'owned supervisor and workers stopped'
            except Exception as error:
                observed['shutdown_error'] = str(error)
                cleanup_error = error
        elif process:
            cleanup_error = RuntimeError('daemon exited before owned shutdown acknowledgement')
        if process:
            stop(process)
        observed['raw_wire'] = [client.raw_wire for client in clients]
        observed['parsed_wire'] = [client.wire for client in clients]
        for client in clients:
            client.close()
        if log:
            log.close()
            observed['daemon_log'] = (root / 'daemon.log').read_text(errors='replace')[-6000:]
        provider.shutdown()
        provider.server_close()
        try:
            settle_owned_processes(root, observed)
        except Exception as error:
            cleanup_error = cleanup_error or error
        if cleanup_error:
            observed['verified'] = False
            observed['cleanup_error'] = str(cleanup_error)
            if primary_error is None:
                raise RuntimeError('fixture cleanup failed: ' + str(cleanup_error)) from cleanup_error
    observed['verified'] = True


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('--receipt', type=Path, required=True)
    args = parser.parse_args()
    receipt = {'scenario': 'client_write_cleanup', 'verified': False,
        'scope': 'real attached-client read-half-close, rename triggers failed write, observed detach and non-owner pause-release probe, then second-client queue drain',
        'not_covered': 'admission cancellation races or direct worker attach-state introspection'}
    try:
        with tempfile.TemporaryDirectory(prefix='pa-write-cleanup-', dir='/tmp') as folder:
            binary = Path(os.environ['PA_RUST_BINARY']).resolve()
            receipt['binary_sha256'] = digest(binary)
            observed = receipt['case'] = {}
            run_case(binary, Path(folder) / 'rust', observed)
        receipt['verified'] = True
    except Exception as error:
        receipt['error'] = str(error)
        raise
    finally:
        args.receipt.parent.mkdir(parents=True, exist_ok=True)
        args.receipt.write_text(json.dumps(receipt, ensure_ascii=False, indent=2))


if __name__ == '__main__':
    main()