Skip to content

The agent that grows with you

4.1 KB
Raw Blame
"""A watchdog timeout remains failed when the handler projects its diagnostic as text."""
from types import SimpleNamespace
import time

import pytest

from gateway.config import Platform
from gateway.session import SessionSource
from gateway.session_authority import LiveSession
from gateway.session_contract import SessionRef
from hermes_state_runtime import admit_session_input, claim_session_input, get_session_admission


@pytest.mark.asyncio
@pytest.mark.parametrize('platform', [Platform.LOCAL, Platform.TELEGRAM])
@pytest.mark.parametrize('late_result', [False, True])
async def test_timeout_diagnostic_keeps_failed_receipt_after_string_projection(owner, platform, late_result):
    from gateway.run import GatewayRunner
    from gateway.run_turn_persistence import GatewayTurnPersistenceMixin
    from gateway.session_ingress import execute_admission
    from gateway.session_results import execution_result, finish_result, admission_result
    from gateway.turn_context import TurnContext
    owner.db.create_session('s', source='cli')
    source = SessionSource(platform, 's', user_id='human')
    owner.sessions['s'] = LiveSession(source, 'route')
    owner.runner._adapter_for_source = lambda source: None
    owner.runner._agent_activity_summary = lambda agent: {'seconds_since_activity': 1800}
    owner.runner._is_intentional_silence = lambda *args: False
    diagnostic = []

    async def handle(event):
        raw = GatewayRunner._run_agent_timeout_result(owner.runner,
            SimpleNamespace(agent_timeout=1800), TurnContext(session_key='route'))
        response, _, _ = await GatewayTurnPersistenceMixin._hmwa_shape_agent_response(
            owner.runner, raw, source, [], SimpleNamespace(session_id='s'), None,
            None, 1, 's', platform.value, time.time())
        diagnostic.append(response)
        if late_result:
            # The abandoned executor shares the capture dict and can return while the handler
            # is still unwinding. Its later value cannot replace the owner's timeout verdict.
            execution_result.get()['result'] = {'final_response': 'late worker answer', 'completed': True}
        return response

    owner.runner._handle_message = handle
    admitted = admit_session_input(owner.db, epoch=owner.epoch, principal_id='human',
        session_id='s', request_id='timeout', payload={'text': 'work'})
    row = claim_session_input(owner.db, epoch=owner.epoch, session_id='s')
    response = await execute_admission(owner, SessionRef(owner.profile_id, 's'), row)
    finish_result(owner.db, epoch=owner.epoch, row=row, response=response, outcome='completed',
                  result=owner.pending_results[admitted['admission_id']])
    saved = admission_result(owner.db, admitted['admission_id'])['result']
    assert get_session_admission(owner.db, admission_id=admitted['admission_id'])['outcome'] == 'failed'
    assert saved['failed'] is True and saved['completed'] is False
    assert saved['final_response'] == response == diagnostic[0]


@pytest.mark.asyncio
async def test_owner_notice_without_execution_is_still_completed(owner):
    from gateway.session_ingress import execute_admission
    from gateway.session_results import finish_result
    owner.db.create_session('notice', source='telegram')
    source = SessionSource(Platform.TELEGRAM, 'notice', user_id='human')
    owner.sessions['notice'] = LiveSession(source, 'notice-route')
    owner.runner._adapter_for_source = lambda source: None
    async def notice(event):
        return 'Gateway is paused by the operator.'
    owner.runner._handle_message = notice
    admitted = admit_session_input(owner.db, epoch=owner.epoch, principal_id='human',
        session_id='notice', request_id='notice', payload={'text': 'work'})
    row = claim_session_input(owner.db, epoch=owner.epoch, session_id='notice')
    response = await execute_admission(owner, SessionRef(owner.profile_id, 'notice'), row)
    finish_result(owner.db, epoch=owner.epoch, row=row, response=response, outcome='completed',
                  result=owner.pending_results[admitted['admission_id']])
    assert get_session_admission(owner.db, admission_id=admitted['admission_id'])['outcome'] == 'completed'