run_interrupt_test.py

#!/usr/bin/env python3
"""Run a real interrupt test with actual AIAgent + delegate child.

Not a pytest test — runs directly as a script for live testing.
"""

import threading
import time
import sys
import os

sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from unittest.mock import MagicMock, patch
from run_agent import AIAgent, IterationBudget
from tools.delegate_tool import _run_single_child
from tools.interrupt import set_interrupt, is_interrupted

def main() -> int:
    set_interrupt(False)

    # Create parent agent (minimal)
    parent = AIAgent.__new__(AIAgent)
    parent._interrupt_requested = False
    parent._interrupt_message = None
    parent._active_children = []
    parent._active_children_lock = threading.Lock()
    parent.quiet_mode = True
    parent.model = "test/model"
    parent.base_url = "http://localhost:1"
    parent.api_key = "test"
    parent.provider = "test"
    parent.api_mode = "chat_completions"
    parent.platform = "cli"
    parent.enabled_toolsets = ["terminal", "file"]
    parent.providers_allowed = None
    parent.providers_ignored = None
    parent.providers_order = None
    parent.provider_sort = None
    parent.max_tokens = None
    parent.reasoning_config = None
    parent.prefill_messages = None
    parent._session_db = None
    parent._delegate_depth = 0
    parent._delegate_spinner = None
    parent.tool_progress_callback = None
    parent.iteration_budget = IterationBudget(max_total=100)
    parent._client_kwargs = {"api_key": "test", "base_url": "http://localhost:1"}

    child_started = threading.Event()
    result_holder = [None]

    def run_delegate():
        with patch("run_agent.OpenAI") as MockOpenAI:
            mock_client = MagicMock()

            def slow_create(**kwargs):
                time.sleep(3)
                resp = MagicMock()
                resp.choices = [MagicMock()]
                resp.choices[0].message.content = "Done"
                resp.choices[0].message.tool_calls = None
                resp.choices[0].message.refusal = None
                resp.choices[0].finish_reason = "stop"
                resp.usage.prompt_tokens = 100
                resp.usage.completion_tokens = 10
                resp.usage.total_tokens = 110
                resp.usage.prompt_tokens_details = None
                return resp

            mock_client.chat.completions.create = slow_create
            mock_client.close = MagicMock()
            MockOpenAI.return_value = mock_client

            original_init = AIAgent.__init__

            def patched_init(self_agent, *a, **kw):
                original_init(self_agent, *a, **kw)
                child_started.set()

            with patch.object(AIAgent, "__init__", patched_init):
                try:
                    result = _run_single_child(
                        task_index=0,
                        goal="Test slow task",
                        context=None,
                        toolsets=["terminal"],
                        model="test/model",
                        max_iterations=5,
                        parent_agent=parent,
                        task_count=1,
                        override_provider="test",
                        override_base_url="http://localhost:1",
                        override_api_key="test",
                        override_api_mode="chat_completions",
                    )
                    result_holder[0] = result
                except Exception as e:
                    print(f"ERROR in delegate: {e}")
                    import traceback
                    traceback.print_exc()

    print("Starting agent thread...")
    agent_thread = threading.Thread(target=run_delegate, daemon=True)
    agent_thread.start()

    started = child_started.wait(timeout=10)
    if not started:
        print("ERROR: Child never started")
        set_interrupt(False)
        return 1

    time.sleep(0.5)

    print(f"Active children: {len(parent._active_children)}")
    for i, c in enumerate(parent._active_children):
        print(f"  Child {i}: _interrupt_requested={c._interrupt_requested}")

    t0 = time.monotonic()
    parent.interrupt("User typed a new message")
    print("Called parent.interrupt()")

    for i, c in enumerate(parent._active_children):
        print(f"  Child {i} after interrupt: _interrupt_requested={c._interrupt_requested}")
    print(f"Global is_interrupted: {is_interrupted()}")

    agent_thread.join(timeout=10)
    elapsed = time.monotonic() - t0
    print(f"Agent thread finished in {elapsed:.2f}s")

    result = result_holder[0]
    if result:
        print(f"Status: {result['status']}")
        print(f"Duration: {result['duration_seconds']}s")
        if elapsed < 2.0:
            print("✅ PASS: Interrupt detected quickly!")
        else:
            print(f"❌ FAIL: Took {elapsed:.2f}s — interrupt was too slow or not detected")
    else:
        print("❌ FAIL: No result!")

    set_interrupt(False)
    return 0


if __name__ == "__main__":
    sys.exit(main())