Skip to content

Agent Zero AI framework

12.9 KB
Raw Blame
from types import SimpleNamespace
from unittest.mock import AsyncMock

import pytest

from agent import Agent
from helpers.llm_result import LLMResult
from plugins._context_doctor.extensions.python.message_loop_result._10_context_doctor import (
    ContextDoctor,
)
from plugins._context_doctor.helpers.context_doctor import (
    looks_like_tool_call,
    transform_response,
    update_log_item,
)


def test_repairs_and_minifies_tool_call():
    response = '{"tool_name":"response","tool_args":{"text":"ok",},}'

    assert transform_response(response, suppress_xml=True) == (
        '{"tool_name":"response","tool_args":{"text":"ok"}}'
    )


def test_chooses_most_complete_tool_call():
    response = (
        '{"tool_name":"first","tool_args":{}} '
        '{"thoughts":["x"],"headline":"Second","tool_name":"second","tool_args":{"x":1}}'
    )

    assert transform_response(response, suppress_xml=True) == (
        '{"thoughts":["x"],"headline":"Second","tool_name":"second","tool_args":{"x":1}}'
    )


def test_wraps_raw_text_in_thoughts():
    assert transform_response("plain text", suppress_xml=True) == (
        '{"thoughts":["plain text"]}'
    )


def test_does_not_wrap_json_with_thoughts_or_headline():
    response = '{"thoughts":["Reasoning"],"headline":"A title"}'

    assert transform_response(response, suppress_xml=True) == response


def test_does_not_wrap_json_with_only_headline():
    response = '{"headline":"Just a headline"}'

    assert transform_response(response, suppress_xml=True) == response


def test_does_not_wrap_json_with_only_thoughts():
    response = '{"thoughts":["only thoughts"]}'

    assert transform_response(response, suppress_xml=True) == response


def test_suppresses_xml_when_enabled():
    assert transform_response("<tool>response</tool>", suppress_xml=True) == "{}"
    assert transform_response("<tool>response</tool>", suppress_xml=False) == (
        '{"thoughts":["<tool>response</tool>"]}'
    )


def test_splits_blank_line_thoughts_after_repair():
    response = '{"thoughts":["first\\n\\nsecond"]}'

    assert transform_response(response, suppress_xml=True) == (
        '{"thoughts":["first","second"]}'
    )


def test_splits_blank_lines_in_raw_text_fallback():
    assert transform_response("first\n\nsecond", suppress_xml=False) == (
        '{"thoughts":["first","second"]}'
    )


def test_keeps_blank_line_thoughts_when_split_disabled():
    assert transform_response(
        "first\n\nsecond", suppress_xml=False, split_thoughts=False
    ) == '{"thoughts":["first\\n\\nsecond"]}'


def test_updates_log_kvps_and_heading_while_preserving_raw_content():
    log_item = SimpleNamespace(
        kvps={"reasoning": "because"},
        update=lambda **kwargs: setattr(log_item, "data", kwargs),
    )
    raw = '{"tool_name":"response","tool_args":{"text":"ok",},}'
    repaired = '{"headline":"Done","tool_name":"response","tool_args":{"text":"ok"}}'

    update_log_item(
        SimpleNamespace(agent_name="A0"),
        log_item,
        repaired,
        update_log=False,
        raw_response=raw,
    )

    assert log_item.data["content"] == raw
    assert log_item.data["kvps"]["reasoning"] == "because"
    assert log_item.data["kvps"]["tool_name"] == "response"
    assert log_item.data["heading"] == "A0: Done"


def test_converted_to_thoughts_rejects_plain_text_wrap():
    assert not looks_like_tool_call("plain text", '{"thoughts":["plain text"]}')


def test_converted_to_thoughts_rejects_split_multi_paragraph_wrap():
    response = "first\n\nsecond"
    transformed = '{"thoughts":["first","second"]}'
    assert not looks_like_tool_call(response, transformed)


def test_transform_and_fallback_agree_on_multi_paragraph_raw_text():
    response = "first\n\nsecond"
    transformed = transform_response(response, suppress_xml=False)
    assert not looks_like_tool_call(response, transformed)


def test_converted_to_thoughts_detects_native_thoughts_json():
    response = '{"thoughts":["only thoughts"]}'

    assert looks_like_tool_call(response, response)


def test_looks_like_tool_call_detects_tool_calls():
    response = '{"tool_name":"response","tool_args":{"text":"ok"}}'

    assert looks_like_tool_call(response, response)


def test_looks_like_tool_call_rejects_empty_dict():
    assert not looks_like_tool_call("<x>y</x>", "{}")


def test_looks_like_tool_call_rejects_non_a0_dict():
    assert not looks_like_tool_call('{"foo":"bar"}', '{"foo":"bar"}')


def test_looks_like_tool_call_rejects_empty_thoughts_list():
    assert not looks_like_tool_call('{"thoughts":[]}', '{"thoughts":[]}')


def test_looks_like_tool_call_rejects_blank_thoughts_entries():
    assert not looks_like_tool_call('{"thoughts":["","  "]}', '{"thoughts":["","  "]}')


def test_looks_like_tool_call_rejects_empty_headline():
    assert not looks_like_tool_call('{"headline":""}', '{"headline":""}')


def test_looks_like_tool_call_rejects_empty_tool_name():
    assert not looks_like_tool_call('{"tool_name":""}', '{"tool_name":""}')


def test_looks_like_tool_call_rejects_empty_tool_args():
    assert not looks_like_tool_call('{"tool_args":{}}', '{"tool_args":{}}')


def test_looks_like_tool_call_rejects_wrong_thoughts_type():
    assert not looks_like_tool_call('{"thoughts":"x"}', '{"thoughts":"x"}')


@pytest.mark.asyncio
@pytest.mark.parametrize("mode", ["responses", "chat_completions"])
@pytest.mark.parametrize("text", [
    "Running the command now.",
    '<tool>response</tool>',
    '{"tool_name":"response","tool_args":{"text":"second call"}}',
])
async def test_extension_leaves_native_calls_and_accompanying_text_intact(monkeypatch, mode, text):
    monkeypatch.setattr(
        "plugins._context_doctor.extensions.python.message_loop_result._10_context_doctor.get_plugin_config",
        lambda *args, **kwargs: {},
    )
    llm_result = LLMResult.from_response({
        "id": "resp_native",
        "usage": {"input_tokens": 2048, "input_tokens_details": {"cached_tokens": 1024}},
        "output": [
            {"type": "message", "role": "assistant", "content": [
                {"type": "output_text", "text": text},
            ]},
            {"type": "function_call", "name": "code_execution_tool",
             "call_id": "call_native", "arguments": '{"runtime":"terminal","code":"echo hi"}'},
        ],
    }, mode=mode)
    before = llm_result.to_dict()
    result_data = {"llm_result": llm_result}

    agent = SimpleNamespace(
        agent_name="A0",
        context=SimpleNamespace(log=SimpleNamespace(log=lambda **kwargs: None)),
        loop_data=SimpleNamespace(params_temporary={}),
        hist_add_ai_response=lambda *args, **kwargs: None,
        hist_add_warning=lambda **kwargs: SimpleNamespace(id="warning"),
        read_prompt=lambda name: name,
        get_data=lambda key: {},
        _log_response_builtin_items=AsyncMock(),
        _execute_tool_request=AsyncMock(return_value=None),
    )
    ContextDoctor(agent).execute(result_data)

    assert llm_result.to_dict() == before
    assert not result_data.get("skip_default_processing")
    assert [call.name for call in llm_result.function_calls] == ["code_execution_tool"]
    await Agent.process_llm_result_tools(agent, llm_result)
    agent._execute_tool_request.assert_awaited_once()
    assert agent._execute_tool_request.call_args.kwargs["tool_name"] == "code_execution_tool"


@pytest.mark.asyncio
@pytest.mark.parametrize("text", ["Done.", "First paragraph.\n\nSecond paragraph.", "<p>Done.</p>"])
async def test_responses_text_reaches_core_response_dispatch(monkeypatch, text):
    monkeypatch.setattr(
        "plugins._context_doctor.extensions.python.message_loop_result._10_context_doctor.get_plugin_config",
        lambda *args, **kwargs: {},
    )
    result = LLMResult.from_response({"id": "resp_text", "output_text": text})
    before = result.to_dict()
    agent = SimpleNamespace(
        _log_response_builtin_items=AsyncMock(),
        _execute_tool_request=AsyncMock(return_value="finished"),
    )
    data = {"llm_result": result}
    ContextDoctor(agent).execute(data)
    assert result.to_dict() == before
    assert not data.get("skip_default_processing")
    assert await Agent.process_llm_result_tools(agent, result) == "finished"
    agent._execute_tool_request.assert_awaited_once_with(
        tool_name="response", tool_args={"text": text}, message=text,
    )


@pytest.mark.parametrize("mode", ["responses", "chat_completions"])
def test_extension_replaces_result_refreshes_log_and_response_item(monkeypatch, mode):
    monkeypatch.setattr(
        "plugins._context_doctor.extensions.python.message_loop_result._10_context_doctor.get_plugin_config",
        lambda *args, **kwargs: {"suppress_xml": True, "update_log": False},
    )
    llm_result = SimpleNamespace(
        mode=mode,
        response='{"tool_name":"response","tool_args":{"text":"ok",},}'
    )
    log_item = SimpleNamespace(
        id="generating", update=lambda **kwargs: setattr(log_item, "data", kwargs)
    )
    response_item = SimpleNamespace(
        update=lambda **kwargs: setattr(response_item, "data", kwargs)
    )
    context = SimpleNamespace(log=SimpleNamespace(log=lambda **kwargs: response_item))
    agent = SimpleNamespace(
        agent_name="A0",
        context=context,
        loop_data=SimpleNamespace(params_temporary={"log_item_generating": log_item}),
    )

    ContextDoctor(agent).execute({"llm_result": llm_result})

    assert llm_result.response == '{"tool_name":"response","tool_args":{"text":"ok"}}'
    assert log_item.data["content"] != llm_result.response
    assert log_item.data["kvps"]["tool_name"] == "response"
    assert response_item.data == {"content": "ok"}


def test_extension_does_not_create_response_item_for_other_tools(monkeypatch):
    monkeypatch.setattr(
        "plugins._context_doctor.extensions.python.message_loop_result._10_context_doctor.get_plugin_config",
        lambda *args, **kwargs: {"suppress_xml": True, "update_log": False},
    )
    log_item = SimpleNamespace(id="generating", update=lambda **kwargs: None)
    agent = SimpleNamespace(
        agent_name="A0",
        context=SimpleNamespace(log=SimpleNamespace(log=lambda **kwargs: None)),
        loop_data=SimpleNamespace(params_temporary={"log_item_generating": log_item}),
    )
    llm_result = SimpleNamespace(
        response='{"tool_name":"notify_user","tool_args":{"message":"not final"}}'
    )

    ContextDoctor(agent).execute({"llm_result": llm_result})

    assert "log_item_response" not in agent.loop_data.params_temporary


def test_extension_does_not_use_legacy_response_message_key(monkeypatch):
    monkeypatch.setattr(
        "plugins._context_doctor.extensions.python.message_loop_result._10_context_doctor.get_plugin_config",
        lambda *args, **kwargs: {"suppress_xml": True, "update_log": False},
    )
    log_item = SimpleNamespace(id="generating", update=lambda **kwargs: None)
    agent = SimpleNamespace(
        agent_name="A0",
        context=SimpleNamespace(log=SimpleNamespace(log=lambda **kwargs: None)),
        loop_data=SimpleNamespace(params_temporary={"log_item_generating": log_item}),
    )
    llm_result = SimpleNamespace(
        response='{"tool_name":"response","tool_args":{"message":"not final"}}'
    )

    ContextDoctor(agent).execute({"llm_result": llm_result})

    assert "log_item_response" not in agent.loop_data.params_temporary


def test_extension_handles_raw_text_fallback_with_warning_and_skip(monkeypatch):
    monkeypatch.setattr(
        "plugins._context_doctor.extensions.python.message_loop_result._10_context_doctor.get_plugin_config",
        lambda *args, **kwargs: {"suppress_xml": True, "update_log": False},
    )
    log_item = SimpleNamespace(
        id="generating", kvps={"reasoning": "thinking"},
        update=lambda **kwargs: setattr(log_item, "data", kwargs),
    )
    logs = []
    warnings = []
    ai_responses = []
    agent = SimpleNamespace(
        agent_name="A0",
        context=SimpleNamespace(log=SimpleNamespace(log=lambda **kwargs: logs.append(kwargs))),
        loop_data=SimpleNamespace(params_temporary={"log_item_generating": log_item}),
        read_prompt=lambda name, **kwargs: {
            "fw.msg_thoughts_fallback.md": "fallback warning",
            "fw.msg_thoughts_fallback_response.md": "fallback notice",
        }[name],
        hist_add_ai_response=lambda message, **kwargs: ai_responses.append(message) or SimpleNamespace(id="ai"),
        hist_add_warning=lambda message: warnings.append(message) or SimpleNamespace(id="warning"),
    )
    llm_result = LLMResult.from_chat(response="Hello there…")
    result_data = {"llm_result": llm_result}

    ContextDoctor(agent).execute(result_data)

    assert result_data["skip_default_processing"] is True
    assert llm_result.response == '{"thoughts":["Hello there…"]}'
    assert ai_responses == ['{"thoughts":["Hello there…"]}']
    assert warnings == ["fallback warning"]
    assert logs[0]["content"] == "A0: fallback notice"
    assert logs[0]["id"] == "warning"
    assert log_item.data["kvps"]["reasoning"] == "thinking"
    assert log_item.data["content"] == "Hello there…"