Skip to content

JiuwenSwarm is an intelligent AI Agent built on openJiuwen. It extends the powerful capabilities of large language models directly to your fingertips through various communication apps you use daily.

Python
9.8 KB
Raw Blame
# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.

"""验证交互续轮绑定 TaskPlan 任务的补丁行为。"""

from __future__ import annotations

import uuid
from types import SimpleNamespace
from unittest.mock import AsyncMock

import pytest

from openjiuwen.core.controller.modules.task_manager import TaskFilter
from openjiuwen.core.controller.schema.task import (
    Task as CoreTask,
    TaskStatus as CoreTaskStatus,
)
from openjiuwen.core.single_agent import AgentCard, create_agent_session
from openjiuwen.harness.deep_agent import DeepAgent
from openjiuwen.harness.schema.interaction import (
    ActiveInteractionRound,
    RoundWorkItem,
)
from openjiuwen.harness.schema.task import TaskPlan, TodoItem, TodoStatus
from openjiuwen.harness.task_loop.task_loop_event_executor import (
    DEEP_TASK_TYPE,
)

from jiuwenswarm.server.runtime.agent_adapter.deepagent_task_plan_binding_patch import (
    _make_patched_run_one_round,
    _resolve_plan_task_id,
    apply_deepagent_task_plan_binding_patch,
    remove_deepagent_task_plan_binding_patch,
)


@pytest.fixture
def plan_binding_patch():
    apply_deepagent_task_plan_binding_patch()
    yield
    remove_deepagent_task_plan_binding_patch()


def _make_agent_with_plan() -> tuple[DeepAgent, object]:
    agent = DeepAgent(AgentCard(name="test-agent"))
    agent._react_agent = SimpleNamespace(
        invoke=AsyncMock(return_value={"output": "任务已完成", "result_type": "answer"}),
        write_invoke_result_to_stream=AsyncMock(return_value=None),
    )
    session = create_agent_session(session_id="sess-patch", card=agent.card)
    state = agent.load_state(session)
    state.task_plan = TaskPlan(
        goal="goal",
        tasks=[
            TodoItem(id="t1", content="done-task", activeForm="done-task",
                     status=TodoStatus.COMPLETED),
            TodoItem(id="t2", content="pending-task", activeForm="pending-task",
                     status=TodoStatus.PENDING),
        ],
    )
    agent.save_state(session, state)
    return agent, session


def _continuation_work() -> RoundWorkItem:
    return RoundWorkItem.user(
        request_id="req-1",
        inputs={"query": "user query"},
        reset_loop=False,
    )


@pytest.mark.asyncio
async def test_continuation_round_binds_plan_task_and_converges(plan_binding_patch):
    """验证 补丁后续轮绑定 TaskPlan pending 任务,任务完成且循环终止。"""
    agent, session = _make_agent_with_plan()
    coordinator, controller = await agent.prepare_interaction_task_loop(session)

    outcome = await agent.run_one_round(
        _continuation_work(), uuid.uuid4().hex, session
    )

    state = agent.load_state(session)
    plan = state.task_plan
    assert plan.get_task("t2").status is TodoStatus.COMPLETED
    assert plan.get_next_task() is None
    assert outcome.next_work is None

    next_work = agent._build_interaction_next_work(
        work=_continuation_work(),
        result={"output": "任务已完成", "result_type": "answer"},
        session=session,
        coordinator=coordinator,
        controller=controller,
    )
    assert next_work is None

    await controller.stop()


@pytest.mark.asyncio
async def test_first_round_keeps_random_task_id(plan_binding_patch):
    """验证 首轮(reset_loop=True)不绑定 plan 任务,保持原有行为。"""
    agent, session = _make_agent_with_plan()
    _coordinator, controller = await agent.prepare_interaction_task_loop(session)

    first_round = RoundWorkItem.user(
        request_id="req-1",
        inputs={"query": "user query"},
        reset_loop=True,
    )
    await agent.run_one_round(first_round, uuid.uuid4().hex, session)

    state = agent.load_state(session)
    assert state.task_plan.get_task("t2").status is TodoStatus.PENDING

    await controller.stop()


@pytest.mark.asyncio
async def test_follow_up_round_keeps_random_task_id(plan_binding_patch):
    """验证 follow_up 轮不绑定 plan 任务,保持原有行为。"""
    agent, session = _make_agent_with_plan()
    _coordinator, controller = await agent.prepare_interaction_task_loop(session)

    follow_up = RoundWorkItem.user(
        request_id="req-1",
        inputs={"query": "user query"},
        is_follow_up=True,
        reset_loop=False,
    )
    await agent.run_one_round(follow_up, uuid.uuid4().hex, session)

    state = agent.load_state(session)
    assert state.task_plan.get_task("t2").status is TodoStatus.PENDING

    await controller.stop()


@pytest.mark.asyncio
async def test_active_round_task_id_rebound_to_plan_task():
    """验证 绑定发生时 ActiveInteractionRound.task_id 同步为 plan 任务 id。"""
    agent, session = _make_agent_with_plan()

    work = _continuation_work()
    random_id = uuid.uuid4().hex
    agent._active_interaction_round = ActiveInteractionRound(work=work, task_id=random_id)

    captured = {}

    async def _probe(self, w, task_id, sess):
        captured["task_id"] = task_id
        captured["active_task_id"] = self._active_interaction_round.task_id
        return SimpleNamespace(next_work=None, error_code=None, error_message=None)

    patched = _make_patched_run_one_round(_probe)
    await patched(agent, work, random_id, session)

    assert captured["task_id"] == "t2"
    assert captured["active_task_id"] == "t2"

    agent._active_interaction_round = None


@pytest.mark.asyncio
async def test_patch_apply_remove_roundtrip():
    """验证 补丁 apply/remove 可往返且幂等(断言失败也不泄漏全局补丁状态)。"""
    original = DeepAgent.run_one_round

    try:
        apply_deepagent_task_plan_binding_patch()
        apply_deepagent_task_plan_binding_patch()
        assert DeepAgent.run_one_round is not original
    finally:
        remove_deepagent_task_plan_binding_patch()
        remove_deepagent_task_plan_binding_patch()
    assert DeepAgent.run_one_round is original


async def _occupy_plan_task(
    agent: DeepAgent, session, task_id: str, status: CoreTaskStatus
) -> None:
    """在已就绪的控制器上注入残留 CoreTask(模拟 SUBMITTED 窗口取消等残留)。"""
    await agent.loop_controller.task_manager.add_task(
        CoreTask(
            session_id=session.get_session_id(),
            task_id=task_id,
            task_type=DEEP_TASK_TYPE,
            description="occupied",
            status=status,
        )
    )


@pytest.mark.asyncio
async def test_zombie_terminal_core_task_marks_plan_cancelled_and_binds_next():
    """验证 终态残留占用时标记 plan 任务取消并绑定下一 pending 任务。"""
    agent, session = _make_agent_with_plan()
    state = agent.load_state(session)
    state.task_plan.tasks.append(
        TodoItem(id="t3", content="next-task", activeForm="next-task",
                 status=TodoStatus.PENDING),
    )
    agent.save_state(session, state)
    _coordinator, controller = await agent.prepare_interaction_task_loop(session)
    # 模拟 SUBMITTED 窗口取消后残留的终态 CoreTask
    await _occupy_plan_task(agent, session, "t2", CoreTaskStatus.CANCELED)

    resolved = await _resolve_plan_task_id(agent, session, _continuation_work())

    assert resolved == "t3"
    plan = agent.load_state(session).task_plan
    assert plan.get_task("t2").status is TodoStatus.CANCELLED
    assert plan.get_task("t3").status is TodoStatus.PENDING

    await controller.stop()


@pytest.mark.asyncio
async def test_all_pending_zombie_marks_all_cancelled_returns_none():
    """验证 全部 pending 被终态残留占用时全部标记取消,循环可收敛。"""
    agent, session = _make_agent_with_plan()
    _coordinator, controller = await agent.prepare_interaction_task_loop(session)
    await _occupy_plan_task(agent, session, "t2", CoreTaskStatus.CANCELED)

    resolved = await _resolve_plan_task_id(agent, session, _continuation_work())

    assert resolved is None
    plan = agent.load_state(session).task_plan
    assert plan.get_task("t2").status is TodoStatus.CANCELLED
    assert agent._has_remaining_tasks(session) is False

    await controller.stop()


@pytest.mark.asyncio
async def test_inflight_core_task_falls_back_to_raw_task_id():
    """验证 非终态(在飞)占用时回退原始 task_id,plan 任务保持不变。"""
    agent, session = _make_agent_with_plan()
    _coordinator, controller = await agent.prepare_interaction_task_loop(session)
    await _occupy_plan_task(agent, session, "t2", CoreTaskStatus.WORKING)

    resolved = await _resolve_plan_task_id(agent, session, _continuation_work())

    assert resolved is None
    plan = agent.load_state(session).task_plan
    assert plan.get_task("t2").status is TodoStatus.PENDING

    await controller.stop()


@pytest.mark.asyncio
async def test_continuation_round_recovers_from_zombie_and_converges(plan_binding_patch):
    """验证 僵尸占用后续轮自愈:跳过僵尸任务、执行下一任务、循环收敛。"""
    agent, session = _make_agent_with_plan()
    state = agent.load_state(session)
    state.task_plan.tasks.append(
        TodoItem(id="t3", content="next-task", activeForm="next-task",
                 status=TodoStatus.PENDING),
    )
    agent.save_state(session, state)
    _coordinator, controller = await agent.prepare_interaction_task_loop(session)
    await _occupy_plan_task(agent, session, "t2", CoreTaskStatus.CANCELED)

    outcome = await agent.run_one_round(
        _continuation_work(), uuid.uuid4().hex, session
    )

    plan = agent.load_state(session).task_plan
    assert plan.get_task("t2").status is TodoStatus.CANCELLED
    assert plan.get_task("t3").status is TodoStatus.COMPLETED
    assert plan.get_next_task() is None
    assert outcome.next_work is None
    assert outcome.error_code is None

    # 僵尸 CoreTask 仍在 TaskManager,但本轮注册的任务是 t3 而非 t2
    registered = await controller.task_manager.get_task(TaskFilter(task_id="t3"))
    assert registered and registered[0].task_id == "t3"

    await controller.stop()