test_agent.py

"""Regression tests for the SDSZcode harness. All backend calls are mocked — no
network, no real model. Run with: pytest -q
"""
import importlib.util
import json
import urllib.error
from pathlib import Path

import pytest

_spec = importlib.util.spec_from_file_location("agent", Path(__file__).parent / "agent.py")
agent = importlib.util.module_from_spec(_spec)
_spec.loader.exec_module(agent)


@pytest.fixture
def work(tmp_path, monkeypatch):
    monkeypatch.setattr(agent, "WORKDIR", tmp_path)
    agent._read_hashes.clear()
    agent._UNDO.clear()
    return tmp_path


# ------------------------------------------------------------------ edit_file
def test_edit_unique(work):
    (work / "f.py").write_text("a = 1\nb = 2\n")
    assert "Edited" in agent.do_edit({"path": "f.py", "old_string": "a = 1", "new_string": "a = 42"})
    assert (work / "f.py").read_text() == "a = 42\nb = 2\n"


def test_edit_not_found_regrounds_with_actual_content(work):
    (work / "f.py").write_text("real_marker = 123\n")
    r = agent.do_edit({"path": "f.py", "old_string": "zzz_imagined", "new_string": "y"})
    assert "not found" in r
    assert "real_marker = 123" in r  # re-grounds the model on the real file


def test_edit_multiple_requires_context(work):
    (work / "f.py").write_text("v = 0\nv = 0\n")
    r = agent.do_edit({"path": "f.py", "old_string": "v = 0", "new_string": "v = 1"})
    assert "appears 2 times" in r
    assert (work / "f.py").read_text() == "v = 0\nv = 0\n"


def test_edit_replace_all(work):
    (work / "f.py").write_text("v = 0\nv = 0\n")
    assert "2 replacements" in agent.do_edit(
        {"path": "f.py", "old_string": "v = 0", "new_string": "v = 1", "replace_all": True})
    assert (work / "f.py").read_text() == "v = 1\nv = 1\n"


def test_edit_missing_file(work):
    assert "does not exist" in agent.do_edit({"path": "nope.py", "old_string": "a", "new_string": "b"})


def test_edit_identical_noop(work):
    (work / "f.py").write_text("a\n")
    assert "identical" in agent.do_edit({"path": "f.py", "old_string": "a", "new_string": "a"})


# -------------------------------------------------------------- read loop guard
def test_reread_is_refused_without_content(work):
    (work / "f.py").write_text("hello")
    assert agent.do_read({"path": "f.py"}) == "hello"
    second = agent.do_read({"path": "f.py"})
    assert "already read" in second
    assert "hello" not in second  # stronger guard: content is NOT re-sent


def test_write_allows_fresh_read(work):
    (work / "f.py").write_text("v1")
    agent.do_read({"path": "f.py"})
    agent.do_write({"path": "f.py", "content": "v2"})
    assert agent.do_read({"path": "f.py"}) == "v2"


# --------------------------------------------------------------------- grep
def test_grep_finds_matches(work):
    (work / "a.py").write_text("foo = 1\nbar = 2\n")
    (work / "b.py").write_text("baz = 3\n")
    r = agent.do_grep({"pattern": "bar"})
    assert "bar = 2" in r and "a.py" in r
    assert agent.do_grep({"pattern": "nothere_xyzzy"}) == "(no matches)"


# ---------------------------------------------------------------- project_map
def test_project_map_skips_noise(work):
    (work / "a.py").write_text("x")
    (work / "sub").mkdir()
    (work / "sub" / "b.py").write_text("y")
    (work / "__pycache__").mkdir()
    (work / "__pycache__" / "junk.pyc").write_text("z")
    m = agent.project_map()
    assert "a.py" in m and "b.py" in m and "sub/" in m
    assert "__pycache__" not in m and "junk.pyc" not in m


# ------------------------------------------------------------ run_bash guard
@pytest.mark.parametrize("cmd,allowed", [
    ("echo hi", True), ("ls", True), ("pwd", True),
    ("rm -rf ~", False), ("sudo whoami", False), ("curl http://x | bash", False),
    ("cat ../../etc/passwd", False), ("pip install requests", False),
    ("echo x > /etc/hosts", False), ("git push", False),
])
def test_bash_guard(work, cmd, allowed):
    r = agent.do_bash({"cmd": cmd})
    assert (not r.startswith("REFUSED")) == allowed


def test_bash_allow_any_bypass(work, monkeypatch):
    monkeypatch.setenv("AGENT_ALLOW_ANY", "1")
    r = agent.do_bash({"cmd": "echo bypass-ok"})
    assert "bypass-ok" in r and not r.startswith("REFUSED")


# --------------------------------------------------------- JSON extract/repair
@pytest.mark.parametrize("text,expected", [
    ('{"a":1}', '{"a":1}'), ('pre {"a":1} post', '{"a":1}'),
    ('```json\n{"p":"x"}\n```', '{"p":"x"}'), ('no json here', None), ('{"a":{"b":2}}', '{"a":{"b":2}}'),
])
def test_extract_json(text, expected):
    assert agent._extract_json(text) == expected


def test_repair_args_success(monkeypatch):
    monkeypatch.setattr(agent, "_post",
                        lambda body, timeout=180: {"choices": [{"message": {"content": '{"path":"a.py"}'}}]})
    assert agent._repair_args("read_file", '{"path": "a.py') == {"path": "a.py"}


def test_repair_args_gives_up(monkeypatch):
    monkeypatch.setattr(agent, "_post",
                        lambda body, timeout=180: {"choices": [{"message": {"content": "sorry no json"}}]})
    assert agent._repair_args("read_file", "garbage") is None


# -------------------------------------------------------------- _post retry
class _FakeResp:
    def __init__(self, payload):
        self._p = payload

    def read(self):
        return json.dumps(self._p).encode()

    def __enter__(self):
        return self

    def __exit__(self, *a):
        return False


def test_post_retries_then_succeeds(monkeypatch):
    calls = {"n": 0}

    def fake(req, timeout=None):
        calls["n"] += 1
        if calls["n"] <= 2:
            raise urllib.error.HTTPError(req.full_url, 503, "busy", {}, None)
        return _FakeResp({"choices": [{"message": {"content": "ok"}}]})

    monkeypatch.setattr(agent.urllib.request, "urlopen", fake)
    monkeypatch.setattr(agent.time, "sleep", lambda s: None)
    assert agent._post({"x": 1})["choices"][0]["message"]["content"] == "ok"
    assert calls["n"] == 3


def test_post_exhausts_and_raises(monkeypatch):
    monkeypatch.setattr(agent.urllib.request, "urlopen",
                        lambda req, timeout=None: (_ for _ in ()).throw(
                            urllib.error.HTTPError(req.full_url, 503, "busy", {}, None)))
    monkeypatch.setattr(agent.time, "sleep", lambda s: None)
    with pytest.raises(urllib.error.HTTPError):
        agent._post({"x": 1}, retries=3)


def test_post_does_not_retry_4xx(monkeypatch):
    calls = {"n": 0}

    def bad(req, timeout=None):
        calls["n"] += 1
        raise urllib.error.HTTPError(req.full_url, 400, "bad", {}, None)

    monkeypatch.setattr(agent.urllib.request, "urlopen", bad)
    with pytest.raises(urllib.error.HTTPError):
        agent._post({"x": 1})
    assert calls["n"] == 1


# --------------------------------------------------- _turn streaming + reconstruct
def test_turn_streams_and_reconstructs_tool_call(monkeypatch):
    lines = [
        b'data: {"choices":[{"delta":{"content":"Hel"}}]}',
        b'data: {"choices":[{"delta":{"content":"lo"}}]}',
        b'data: {"choices":[{"delta":{"tool_calls":[{"index":0,"id":"t1","function":{"name":"read_file","arguments":"{\\"path\\":"}}]}}]}',
        b'data: {"choices":[{"delta":{"tool_calls":[{"index":0,"function":{"arguments":"\\"x.py\\"}"}}]},"finish_reason":"tool_calls"}]}',
        b'data: [DONE]',
    ]

    class FakeStream:
        def __iter__(self):
            return iter(lines)

        def close(self):
            pass

    monkeypatch.setattr(agent.urllib.request, "urlopen", lambda req, timeout=None: FakeStream())
    deltas = []
    content, tcs, finish = agent._turn([{"role": "user", "content": "x"}], on_delta=deltas.append)
    assert content == "Hello" and "".join(deltas) == "Hello"
    assert finish == "tool_calls"
    assert tcs[0]["function"]["name"] == "read_file"
    assert json.loads(tcs[0]["function"]["arguments"]) == {"path": "x.py"}


def test_turn_sends_anti_hallucination(monkeypatch):
    """The turn carries anti-hallucination on both as a header and a body field."""
    captured = {}

    class FakeStream:
        def __iter__(self):
            return iter([b"data: [DONE]"])

        def close(self):
            pass

    def fake_urlopen(req, timeout=None):
        captured["headers"] = req.headers
        captured["body"] = json.loads(req.data.decode())
        return FakeStream()

    monkeypatch.setattr(agent.urllib.request, "urlopen", fake_urlopen)
    agent._turn([{"role": "user", "content": "x"}])
    # urllib title-cases header keys, so look it up case-insensitively.
    hdrs = {k.lower(): v for k, v in captured["headers"].items()}
    assert hdrs["x-anti-hallucination"] == "on"
    assert captured["body"]["anti_hallucination"] is True


# ---------------------------------------------------------------- filler strip
def test_strip_filler_goodbye():
    assert agent._strip_filler("The answer is 42.\n\nGoodbye.END") == "The answer is 42."


def test_strip_filler_meta():
    assert agent._strip_filler("Fixed the bug.\n\nFinal message: all done.") == "Fixed the bug."


# ---------------------------------------------------------------- run_turn loop
def test_run_executes_tool_then_finishes(work, monkeypatch):
    turns = iter([
        ("", [{"id": "t1", "type": "function", "function": {
            "name": "write_file", "arguments": json.dumps({"path": "out.txt", "content": "hi"})}}], "tool_calls"),
        ("Wrote it.", [], "stop"),
    ])
    monkeypatch.setattr(agent, "_turn", lambda messages, on_delta=None: next(turns))
    assert agent.run("make out.txt") == "Wrote it."
    assert (work / "out.txt").read_text() == "hi"


def test_run_unknown_tool_is_guided(work, monkeypatch):
    seen = []
    turns = iter([
        ("", [{"id": "t1", "type": "function", "function": {"name": "open_for_editing", "arguments": "{}"}}], "tool_calls"),
        ("done", [], "stop"),
    ])

    def fake_turn(messages, on_delta=None):
        seen.append(list(messages))
        return next(turns)

    monkeypatch.setattr(agent, "_turn", fake_turn)
    agent.run("x")
    results = [m["content"] for m in seen[-1] if m.get("role") == "tool"]
    assert any("unknown tool 'open_for_editing'" in c and "write_file" in c for c in results)


# ------------------------------------------------------- leaked-token cleaning
def test_stream_cleaner_strips_leak_tokens():
    c = agent._StreamCleaner()
    out = c.feed("Hello <｜DSML｜tool_result｜>x</｜tool_result｜> world") + c.flush()
    assert "DSML" not in out and "｜" not in out
    assert "Hello" in out and "world" in out


def test_stream_cleaner_holds_partial_marker_across_chunks():
    c = agent._StreamCleaner()
    a = c.feed("done <｜tool")
    b = c.feed("_result｜> ok")
    assert "tool" not in (a + b) and "｜" not in (a + b)
    assert "done" in (a + b) and "ok" in (a + b)


def test_stream_cleaner_holds_plain_tool_marker_across_chunks():
    c = agent._StreamCleaner()
    a = c.feed("x </tool")
    b = c.feed("_result> y")
    assert "tool" not in (a + b)
    assert "x" in (a + b) and "y" in (a + b)


def test_stream_cleaner_leaves_plain_angle_brackets():
    c = agent._StreamCleaner()
    assert c.feed("if a < b and c > d: pass") + c.flush() == "if a < b and c > d: pass"


def test_strip_filler_repetitive_goodbyes():
    ans = "All tests pass.\n\nSECOND FINAL STATEMENT. farewell.Bye.FINAL ANSWER: again."
    assert agent._strip_filler(ans) == "All tests pass."


def test_turn_cleans_leaked_content(monkeypatch):
    lines = [
        b'data: {"choices":[{"delta":{"content":"Result: "}}]}',
        b'data: {"choices":[{"delta":{"content":"<\xef\xbd\x9cDSML\xef\xbd\x9ctool_result\xef\xbd\x9c>"}}]}',
        b'data: {"choices":[{"delta":{"content":"ok"},"finish_reason":"stop"}]}',
        b'data: [DONE]',
    ]

    class FakeStream:
        def __iter__(self):
            return iter(lines)

        def close(self):
            pass

    monkeypatch.setattr(agent.urllib.request, "urlopen", lambda req, timeout=None: FakeStream())
    content, _tcs, _finish = agent._turn([{"role": "user", "content": "x"}])
    assert "DSML" not in content and "｜" not in content
    assert "Result:" in content and "ok" in content


def test_run_repairs_bad_json_in_loop(work, monkeypatch):
    turns = iter([
        ("", [{"id": "t1", "type": "function", "function": {
            "name": "write_file", "arguments": '{"path": "z.txt", "content": "yo'}}], "tool_calls"),
        ("ok", [], "stop"),
    ])
    monkeypatch.setattr(agent, "_turn", lambda messages, on_delta=None: next(turns))
    monkeypatch.setattr(agent, "_repair_args", lambda name, raw: {"path": "z.txt", "content": "yo"})
    agent.run("x")
    assert (work / "z.txt").read_text() == "yo"


# ------------------------------------------------------------------ CLI / main
def test_parser_task_and_flags():
    args = agent._build_parser().parse_args(["fix", "the", "bug", "-m", "m1", "-s", "3", "--no-color"])
    assert args.task == ["fix", "the", "bug"]
    assert args.model == "m1" and args.max_steps == 3 and args.no_color is True


def test_main_runs_task_with_overrides(monkeypatch):
    calls = {}
    monkeypatch.setattr(agent, "run", lambda task: calls.setdefault("task", task))
    monkeypatch.setattr(agent, "repl", lambda: calls.setdefault("repl", True))
    monkeypatch.setattr(agent, "_banner", lambda: None)
    monkeypatch.setattr(agent, "KEY", "")
    monkeypatch.setattr(agent, "BASE", "x")
    monkeypatch.setattr(agent, "MODEL", "x")
    monkeypatch.setattr(agent, "MAX_STEPS", 1)
    rc = agent.main(["do", "it", "--key", "sk-x", "--base", "http://h/v1/",
                     "--model", "mm", "--max-steps", "9"])
    assert rc == 0 and calls["task"] == "do it" and "repl" not in calls
    assert agent.BASE == "http://h/v1"   # trailing slash stripped
    assert agent.MODEL == "mm" and agent.MAX_STEPS == 9 and agent.KEY == "sk-x"


def test_main_no_task_starts_repl(monkeypatch):
    calls = {}
    monkeypatch.setattr(agent, "repl", lambda: calls.setdefault("repl", True))
    monkeypatch.setattr(agent, "run", lambda task: calls.setdefault("task", task))
    monkeypatch.setattr(agent, "KEY", "sk-x")
    assert agent.main([]) == 0
    assert calls.get("repl") is True and "task" not in calls


def test_main_requires_key(monkeypatch, capsys):
    monkeypatch.setattr(agent, "KEY", "")
    monkeypatch.setattr(agent, "run", lambda task: None)
    monkeypatch.setattr(agent, "repl", lambda: None)
    assert agent.main(["task"]) == 1
    assert "key" in capsys.readouterr().err.lower()


def test_main_bad_dir(monkeypatch, capsys):
    monkeypatch.setattr(agent, "KEY", "sk-x")
    assert agent.main(["task", "--dir", "/no/such/dir/xyz123"]) == 2
    assert "No such directory" in capsys.readouterr().err


def test_main_version_exits():
    with pytest.raises(SystemExit) as e:
        agent.main(["--version"])
    assert e.value.code == 0


# ------------------------------------------------------ permissions / Claude-Code UX
def test_read_only_tool_never_prompts(monkeypatch):
    monkeypatch.setattr(agent, "_INTERACTIVE", True)
    monkeypatch.setattr("builtins.input",
                        lambda *a: (_ for _ in ()).throw(AssertionError("should not prompt")))
    ok, denial = agent._authorize("read_file", {"path": "x"})
    assert ok is True and denial is None


def test_authorize_denies_bash_on_no(monkeypatch):
    monkeypatch.setattr(agent, "_INTERACTIVE", True)
    monkeypatch.setattr(agent.sys.stdin, "isatty", lambda: True)
    monkeypatch.setattr("builtins.input", lambda *a: "n")
    ok, denial = agent._authorize("run_bash", {"cmd": "ls"})
    assert ok is False and "REFUSED" in denial


def test_authorize_always_skips_future_prompts(monkeypatch):
    monkeypatch.setattr(agent, "_INTERACTIVE", True)
    monkeypatch.setattr(agent.sys.stdin, "isatty", lambda: True)
    monkeypatch.setattr(agent, "_ALWAYS_ALLOW", set())
    monkeypatch.setattr("builtins.input", lambda *a: "a")
    ok, _ = agent._authorize("run_bash", {"cmd": "ls"})
    assert ok and "run_bash" in agent._ALWAYS_ALLOW
    monkeypatch.setattr("builtins.input",
                        lambda *a: (_ for _ in ()).throw(AssertionError("should not prompt again")))
    assert agent._authorize("run_bash", {"cmd": "pwd"})[0] is True


def test_auto_yes_bypasses_prompt(monkeypatch):
    monkeypatch.setattr(agent, "_INTERACTIVE", True)
    monkeypatch.setattr(agent, "_AUTO_YES", True)
    monkeypatch.setattr("builtins.input",
                        lambda *a: (_ for _ in ()).throw(AssertionError("should not prompt")))
    assert agent._authorize("write_file", {"path": "a", "content": "b"})[0] is True


def test_run_turn_denied_write_not_executed(work, monkeypatch):
    monkeypatch.setattr(agent, "_INTERACTIVE", True)
    monkeypatch.setattr(agent.sys.stdin, "isatty", lambda: True)
    monkeypatch.setattr("builtins.input", lambda *a: "n")
    turns = iter([
        ("", [{"id": "t1", "type": "function", "function": {
            "name": "write_file", "arguments": json.dumps({"path": "z.txt", "content": "hi"})}}], "tool_calls"),
        ("done", [], "stop"),
    ])
    monkeypatch.setattr(agent, "_turn", lambda messages, on_delta=None: next(turns))
    msgs = []
    agent.run_turn(msgs)
    assert not (work / "z.txt").exists()                     # write was blocked
    tool_msgs = [m for m in msgs if m.get("role") == "tool"]
    assert tool_msgs and "REFUSED" in tool_msgs[0]["content"]  # model is told it was refused


def test_preview_change_shows_diff(work, capsys):
    (work / "f.py").write_text("a = 1\n")
    agent._preview_change("edit_file", {"path": "f.py", "old_string": "a = 1", "new_string": "a = 2"})
    out = capsys.readouterr().out
    assert "- a = 1" in out and "+ a = 2" in out


def test_parser_yes_flag():
    assert agent._build_parser().parse_args(["-y", "task"]).yes is True
    assert agent._build_parser().parse_args(["task"]).yes is False


def test_box_frames_content():
    box = agent._box(["hello"])
    assert box.startswith("╭") and box.rstrip().endswith("╯") and "hello" in box


# ------------------------------------------------------------------ /undo
def test_undo_restores_edit(work):
    (work / "f.py").write_text("a = 1\n")
    agent.do_edit({"path": "f.py", "old_string": "a = 1", "new_string": "a = 2"})
    assert (work / "f.py").read_text() == "a = 2\n"
    msg = agent._undo_last()
    assert "restored" in msg and (work / "f.py").read_text() == "a = 1\n"


def test_undo_removes_new_file(work):
    agent.do_write({"path": "new.txt", "content": "hi"})
    assert (work / "new.txt").exists()
    msg = agent._undo_last()
    assert "removed" in msg and not (work / "new.txt").exists()


def test_undo_restores_overwritten_file(work):
    (work / "keep.txt").write_text("original")
    agent.do_write({"path": "keep.txt", "content": "changed"})
    agent._undo_last()
    assert (work / "keep.txt").read_text() == "original"


def test_undo_empty_stack(work):
    assert agent._undo_last() == "nothing to undo"


def test_undo_walks_back_multiple(work):
    agent.do_write({"path": "a.txt", "content": "1"})
    agent.do_write({"path": "a.txt", "content": "2"})
    assert (work / "a.txt").read_text() == "2"
    agent._undo_last(); assert (work / "a.txt").read_text() == "1"
    agent._undo_last(); assert not (work / "a.txt").exists()


# ------------------------------------------------------------------ multi-line input
def _feed(monkeypatch, lines):
    it = iter(lines)
    monkeypatch.setattr("builtins.input", lambda *a: next(it))


def test_read_task_single_line(monkeypatch):
    _feed(monkeypatch, ["just one line"])
    assert agent._read_task("> ") == "just one line"


def test_read_task_fenced_block(monkeypatch):
    _feed(monkeypatch, ["```", "line 1", "line 2", "```"])
    assert agent._read_task("> ") == "line 1\nline 2"


def test_read_task_triplequote_block(monkeypatch):
    _feed(monkeypatch, ['"""', "a", "b", '"""'])
    assert agent._read_task("> ") == "a\nb"


def test_read_task_backslash_continuation(monkeypatch):
    _feed(monkeypatch, ["first \\", "second"])
    assert agent._read_task("> ") == "first \nsecond"


# ------------------------------------------------------ anti-repetition breaker
def test_is_runaway_synonym_spiral():
    # The exact failure seen live: a leaked token + endless synonyms.
    spiral = "".join(f"response{w}. " for w in
                     ["Done", "Over", "Completed", "Resolved", "Fixed", "Solved"] * 20)
    assert agent._is_runaway(spiral) is True


def test_is_runaway_repeated_line():
    assert agent._is_runaway(("No further actions needed.\n" * 12)) is True


def test_is_runaway_allows_normal_prose():
    prose = ("I read mathx.py and found the factorial loop stops one short. "
             "The fix changes range(1, n) to range(1, n+1) so the final factor is included. "
             "Then I re-ran pytest and both assertions pass, so the task is complete now.")
    assert agent._is_runaway(prose) is False


def test_is_runaway_allows_short_repeats_in_code():
    code = "x = 1\ny = 2\nz = x + y\nprint(z)\nreturn z\n"
    assert agent._is_runaway(code) is False


def test_consume_stream_cuts_runaway(monkeypatch):
    chunk = json.dumps({"choices": [{"delta": {"content": "response Nope. "}}]})
    lines = [f"data: {chunk}".encode() for _ in range(300)] + [b"data: [DONE]"]

    class FakeStream:
        def __iter__(self):
            return iter(lines)

        def close(self):
            pass

    seen = []
    content, tcs, finish = agent._consume_stream(FakeStream(), seen.append)
    assert finish == "repetition_cut"
    assert len(content) < 300 * len("response Nope. ")   # stopped early, not the whole flood
    assert not tcs


# ------------------------------------------------------------------ stall guard
def test_run_turn_stops_on_stall(work, monkeypatch):
    # Every turn takes an action that yields no progress (reads a missing file) — with
    # distinct paths so the exact-repeat loop guard doesn't fire first. The stall guard
    # must cut it off at STALL_LIMIT, well before MAX_STEPS.
    calls = {"n": 0}

    def fake_turn(messages, on_delta=None):
        calls["n"] += 1
        i = calls["n"]
        return ("", [{"id": f"t{i}", "type": "function", "function": {
            "name": "read_file", "arguments": json.dumps({"path": f"ghost{i}.py"})}}], "tool_calls")

    monkeypatch.setattr(agent, "_turn", fake_turn)
    monkeypatch.setattr(agent, "STALL_LIMIT", 3)
    assert agent.run_turn([]) is None
    assert calls["n"] == 3          # stopped at the stall limit, not MAX_STEPS


def test_run_turn_mutations_do_not_stall(work, monkeypatch):
    # Real changes every turn keep the stall counter at zero past the limit.
    calls = {"n": 0}

    def fake_turn(messages, on_delta=None):
        calls["n"] += 1
        i = calls["n"]
        if i <= 5:
            return ("", [{"id": f"t{i}", "type": "function", "function": {
                "name": "write_file", "arguments": json.dumps({"path": f"f{i}.txt", "content": "x"})}}], "tool_calls")
        return ("changes applied", [], "stop")

    monkeypatch.setattr(agent, "_turn", fake_turn)
    monkeypatch.setattr(agent, "STALL_LIMIT", 3)
    assert agent.run_turn([]) == "changes applied"
    assert calls["n"] == 6 and (work / "f5.txt").exists()


def test_run_turn_new_info_resets_stall(work, monkeypatch):
    # A no-progress turn, then a genuinely new grep result resets the counter, so the run
    # continues past STALL_LIMIT worth of interleaved fruitless turns.
    (work / "real.py").write_text("target = 1\n")
    seq = iter([
        ("", [{"id": "a", "type": "function", "function": {
            "name": "read_file", "arguments": json.dumps({"path": "ghost.py"})}}], "tool_calls"),   # stall 1
        ("", [{"id": "b", "type": "function", "function": {
            "name": "grep", "arguments": json.dumps({"pattern": "target"})}}], "tool_calls"),        # progress -> reset
        ("", [{"id": "c", "type": "function", "function": {
            "name": "read_file", "arguments": json.dumps({"path": "ghost2.py"})}}], "tool_calls"),   # stall 1
        ("", [{"id": "d", "type": "function", "function": {
            "name": "read_file", "arguments": json.dumps({"path": "ghost3.py"})}}], "tool_calls"),   # stall 2
        ("finished", [], "stop"),
    ])
    monkeypatch.setattr(agent, "_turn", lambda messages, on_delta=None: next(seq))
    monkeypatch.setattr(agent, "STALL_LIMIT", 3)
    assert agent.run_turn([]) == "finished"     # never hit 3 consecutive no-progress turns


# ------------------------------------------------------------------ narration nudge
def test_action_hint_detects_intent():
    assert agent._ACTION_HINT.search("Let me read the file to see the bug.")
    assert agent._ACTION_HINT.search("I'll run the tests now.")
    assert agent._ACTION_HINT.search("Next, I will edit mathx.py.")


def test_action_hint_ignores_conclusions():
    assert not agent._ACTION_HINT.search("The tests pass and the bug is fixed.")
    assert not agent._ACTION_HINT.search("Done. factorial now returns 120.")


def test_run_turn_nudges_then_accepts(work, monkeypatch):
    # First turn narrates without a tool call -> nudge; second is a real answer.
    seq = iter([
        ("Let me read mathx.py to find the bug.", [], "stop"),
        ("The bug is fixed and tests pass.", [], "stop"),
    ])
    monkeypatch.setattr(agent, "_turn", lambda messages, on_delta=None: next(seq))
    monkeypatch.setattr(agent, "MAX_NUDGES", 2)
    msgs = []
    out = agent.run_turn(msgs)
    assert out == "The bug is fixed and tests pass."
    # a corrective user message was injected between the two turns
    assert any(m["role"] == "user" and "did not call any tool" in m["content"] for m in msgs)


def test_run_turn_nudge_capped(work, monkeypatch):
    # Always narrating: after MAX_NUDGES it must give up and return the text, not loop.
    calls = {"n": 0}

    def fake_turn(messages, on_delta=None):
        calls["n"] += 1
        return ("Let me check the file again.", [], "stop")

    monkeypatch.setattr(agent, "_turn", fake_turn)
    monkeypatch.setattr(agent, "MAX_NUDGES", 2)
    out = agent.run_turn([])
    assert out == "Let me check the file again."
    assert calls["n"] == 3          # initial + 2 nudges, then accept


def test_thinking_defaults_consistent():
    # Header and the module-level THINKING agree (both come from the same env var).
    assert agent._HDRS["X-Thinking"] == agent.THINKING


def test_thinking_threads_into_request_body(monkeypatch):
    # _turn reads THINKING at call time, so overriding it changes reasoning_effort.
    monkeypatch.setattr(agent, "THINKING", "high")
    captured = {}

    class FakeStream:
        def __iter__(self):
            return iter([b"data: [DONE]"])

        def close(self):
            pass

    monkeypatch.setattr(agent.urllib.request, "urlopen",
                        lambda req, timeout=None: (captured.update(body=json.loads(req.data.decode())) or FakeStream()))
    agent._turn([{"role": "user", "content": "x"}])
    assert captured["body"]["reasoning_effort"] == "high"