Skip to content

Enterprise agent platform for building, deploying, and operating AI teammates.

39.2 KB
Raw Blame
"""Unit tests for AgentServiceManager task existence checking and reconstruction"""

from datetime import datetime
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock, call, patch

import pytest

from xagent.core.agent.budget import ExecutionBudgetPolicy
from xagent.core.tools.adapters.vibe.config import MCPFailurePolicy
from xagent.web.models.task import (
    DAGExecution,
    DAGExecutionPhase,
    Task,
    TaskStatus,
    TraceEvent,
)
from xagent.web.models.user import User
from xagent.web.services.agent_service_manager import AgentServiceManager
from xagent.web.services.task_setup_snapshot import (
    RuntimeUserFields,
    TaskReconstructionSnapshot,
    TaskSetupSnapshot,
    _TaskFields,
)


@pytest.fixture(autouse=True)
def legacy_task_selection(monkeypatch):
    from xagent.web.services.trace_handlers import DatabaseTraceHandler

    monkeypatch.setattr(
        "xagent.web.tracing.task_database_handler", DatabaseTraceHandler
    )


def _build_reconstruction_snapshot(
    task: Task,
    user: User,
    *,
    trace_events: list[TraceEvent] | None = None,
    dag_execution: DAGExecution | None = None,
    task_llm=None,
    task_pattern: str = "dag_plan_execute",
    agent_config: dict | None = None,
    voice: str | None = None,
) -> TaskSetupSnapshot:
    """Build the detached reconstruction contract consumed on the event loop."""
    trace_events = trace_events or []
    reconstruction = TaskReconstructionSnapshot(
        tracer_events=tuple(
            {
                "id": str(event.event_id),
                "event_type": str(event.event_type),
                "task_id": str(event.task_id),
                "step_id": str(event.step_id) if event.step_id is not None else None,
                "timestamp": event.timestamp.timestamp() if event.timestamp else None,
                "data": dict(event.data or {}),
                "parent_id": (
                    str(event.parent_event_id)
                    if event.parent_event_id is not None
                    else None
                ),
            }
            for event in trace_events
        ),
        plan_state=(
            dict(dag_execution.current_plan)
            if dag_execution is not None and dag_execution.current_plan
            else None
        ),
        has_history=bool(trace_events) or dag_execution is not None,
    )
    return TaskSetupSnapshot(
        task=_TaskFields(
            id=int(task.id),
            user_id=int(task.user_id),
            status=task.status,
            source=task.source,
            agent_id=task.agent_id,
            agent_config=task.agent_config,
            model_name=task.model_name,
            compact_model_name=task.compact_model_name,
            execution_mode=task.execution_mode,
            agent_type=task.agent_type,
        ),
        runtime_user=RuntimeUserFields(
            id=int(user.id),
            is_admin=bool(user.is_admin),
            voice=voice,
        ),
        has_reconstructable_history=reconstruction.has_history,
        task_pattern=task_pattern,
        task_llm=task_llm,
        task_fast_llm=None,
        task_vision_llm=None,
        task_compact_llm=None,
        agent=None,
        agent_config=agent_config,
        excluded_agent_id=None,
        reconstruction=reconstruction,
    )


class TestAgentServiceManagerReconstruction:
    """测试AgentServiceManager的任务重建功能"""

    @pytest.fixture
    def agent_manager(self):
        """创建AgentServiceManager实例"""
        return AgentServiceManager()

    @pytest.fixture
    def mock_db(self):
        """创建mock数据库会话"""
        db = MagicMock()
        db.query = MagicMock()
        return db

    @pytest.fixture
    def mock_user(self):
        """创建mock用户"""
        return User(
            id=1,
            username="test_user",
            password_hash="hashed_password",
            is_admin=False,
        )

    @pytest.fixture
    def sample_task(self):
        """创建示例任务"""
        return Task(
            id=1,
            user_id=1,
            title="Test Task",
            description="Test description",
            status=TaskStatus.PENDING,
            model_name="gpt-4",
            small_fast_model_name="gpt-3.5-turbo",
            agent_type="standard",
        )

    @pytest.fixture
    def sample_trace_events(self):
        """创建示例追踪事件"""
        return [
            TraceEvent(
                id=1,
                task_id=1,
                event_id="event1",
                event_type="task_start_general",
                timestamp=datetime.now(),
                step_id=None,
                parent_event_id=None,
                data={"goal": "Test goal"},
            ),
            TraceEvent(
                id=2,
                task_id=1,
                event_id="event2",
                event_type="step_end_dag",
                timestamp=datetime.now(),
                step_id="step1",
                parent_event_id="event1",
                data={"success": True, "result": "4"},
            ),
        ]

    @pytest.fixture
    def sample_dag_execution(self):
        """创建示例DAG执行记录"""
        return DAGExecution(
            id=1,
            task_id=1,
            phase=DAGExecutionPhase.PLANNING,
            progress_percentage=50.0,
            completed_steps=1,
            total_steps=2,
            current_plan={
                "id": "test_plan",
                "goal": "Test goal",
                "steps": [
                    {
                        "id": "step1",
                        "name": "Test Step",
                        "description": "Test description",
                        "tool_name": "calculator",
                        "tool_args": {"expression": "2+2"},
                        "dependencies": [],
                        "status": "completed",
                        "result": {"result": "4"},
                        "context": {},
                        "difficulty": "easy",
                    }
                ],
            },
        )

    @pytest.mark.asyncio
    async def test_get_agent_for_task_new_task(self, agent_manager, mock_db, mock_user):
        """A missing task is created before its detached snapshot is loaded."""
        persisted_task = Task(
            id=1,
            user_id=1,
            title="Task 1",
            description="Auto-created task",
            status=TaskStatus.PENDING,
            agent_type="standard",
        )
        post_create_snapshot = _build_reconstruction_snapshot(
            persisted_task,
            mock_user,
            task_llm=MagicMock(),
        )
        owner_query = MagicMock()
        owner_query.filter.return_value = owner_query
        owner_query.first.return_value = None
        task_query = MagicMock()
        task_query.filter.return_value = task_query
        task_query.first.return_value = None

        def query(entity):
            if entity is Task.user_id:
                return owner_query
            if entity is Task:
                return task_query
            return MagicMock()

        mock_db.query.side_effect = query
        mock_db.commit = MagicMock()
        mock_db.refresh = MagicMock()
        mock_db.add = MagicMock()

        with (
            patch(
                "xagent.web.services.agent_service_manager.AgentService"
            ) as mock_agent_service_class,
            patch(
                "xagent.web.services.agent_service_manager.load_task_setup_snapshot_sync",
                side_effect=[None, post_create_snapshot],
            ) as snapshot_loader,
            patch(
                "xagent.web.services.agent_service_manager.create_default_tools",
                new=AsyncMock(return_value=([], MagicMock())),
            ),
            patch(
                "xagent.web.services.agent_service_manager.get_memory_store",
                return_value=MagicMock(),
            ),
            patch("xagent.web.sandbox_manager.get_sandbox_manager", return_value=None),
        ):
            # 创建mock AgentService实例
            mock_agent_service = MagicMock()
            mock_agent_service_class.return_value = mock_agent_service

            agent = await agent_manager.get_agent_for_task(
                1,
                mock_db,
                user=mock_user,
                resolved_execution_scope=None,
            )

        assert agent is mock_agent_service
        assert 1 in agent_manager._agents
        assert snapshot_loader.call_args_list == [call(1, None), call(1, 1)]
        created_task = mock_db.add.call_args.args[0]
        assert isinstance(created_task, Task)
        assert created_task.user_id == 1
        assert created_task.status == TaskStatus.PENDING
        mock_db.commit.assert_called_once_with()
        mock_db.refresh.assert_called_once_with(created_task)

    @pytest.mark.asyncio
    async def test_get_agent_for_task_existing_task_no_reconstruction(
        self, agent_manager, mock_db, sample_task, mock_user
    ):
        """测试获取已存在任务的agent,但没有历史数据"""
        snapshot = _build_reconstruction_snapshot(
            sample_task,
            mock_user,
            task_llm=MagicMock(),
        )
        with (
            patch(
                "xagent.web.services.agent_service_manager.AgentService"
            ) as mock_agent_service_class,
            patch(
                "xagent.web.services.agent_service_manager.create_default_tools",
                new=AsyncMock(return_value=([], MagicMock())),
            ),
            patch(
                "xagent.web.services.agent_service_manager.get_memory_store",
                return_value=MagicMock(),
            ),
            patch("xagent.web.sandbox_manager.get_sandbox_manager", return_value=None),
        ):
            mock_agent_service = MagicMock()
            mock_agent_service_class.return_value = mock_agent_service

            agent = await agent_manager.get_agent_for_task(
                1,
                mock_db,
                user=mock_user,
                task_setup_snapshot=snapshot,
                task_owner_user_id=1,
                resolved_execution_scope=None,
            )

        assert agent is not None
        assert 1 in agent_manager._agents
        assert agent_manager._agents[1] == mock_agent_service

    @pytest.mark.asyncio
    async def test_get_agent_for_task_cached_sandbox_without_agent_config(
        self, agent_manager, mock_db, sample_task, mock_user
    ):
        """A cached sandbox should not skip allowed_tools initialization."""
        sandbox_mgr = MagicMock()
        sandbox_mgr.get_or_create_lease_provider = AsyncMock(return_value=MagicMock())
        snapshot = _build_reconstruction_snapshot(
            sample_task,
            mock_user,
            task_llm=MagicMock(),
        )

        with (
            patch(
                "xagent.web.services.agent_service_manager.AgentService"
            ) as mock_agent_service_class,
            patch(
                "xagent.web.services.agent_service_manager.get_memory_store",
                return_value=MagicMock(),
            ),
            patch(
                "xagent.web.sandbox_manager.get_sandbox_manager",
                return_value=sandbox_mgr,
            ),
            patch(
                "xagent.core.tools.adapters.vibe.factory.ToolFactory"
            ) as mock_tool_factory,
        ):
            mock_tool_factory.create_all_tools = AsyncMock(return_value=[])
            mock_tool_factory.create_workspace_async = AsyncMock(
                return_value=MagicMock()
            )
            mock_agent_service = MagicMock()
            mock_agent_service_class.return_value = mock_agent_service

            agent = await agent_manager.get_agent_for_task(
                1,
                mock_db,
                user=mock_user,
                task_setup_snapshot=snapshot,
                task_owner_user_id=1,
                resolved_execution_scope=None,
            )

        assert agent is mock_agent_service
        assert 1 in agent_manager._agents

    @pytest.mark.asyncio
    async def test_admin_task_uses_task_owner_workspace_dirs(
        self, agent_manager, mock_db, tmp_path
    ):
        """Admin executing another user's task should use the task owner's workspace."""
        owner_task = Task(
            id=1,
            user_id=7,
            title="Owner Task",
            description="Task owned by another user",
            status=TaskStatus.PENDING,
            agent_type="standard",
        )
        admin_user = User(
            id=1,
            username="admin",
            password_hash="hashed_password",
            is_admin=True,
        )
        owner_user = User(
            id=7,
            username="owner",
            password_hash="hashed_password",
            is_admin=False,
        )
        snapshot = _build_reconstruction_snapshot(
            owner_task,
            owner_user,
            task_llm=MagicMock(),
        )
        uploads_dir = tmp_path / "uploads"

        with (
            patch(
                "xagent.web.services.agent_service_manager.AgentService"
            ) as mock_agent_service_class,
            patch(
                "xagent.web.services.llm_utils.UserAwareModelStorage.resolve_llms_from_names"
            ) as mock_resolve_llms,
            patch(
                "xagent.web.services.agent_service_manager.get_memory_store"
            ) as mock_get_memory,
            # Backend workspace paths are composed in the workspace
            # projection, so that is the seam the base dir comes from.
            patch(
                "xagent.web.services.workspace_binding.get_uploads_dir",
                return_value=uploads_dir,
            ),
            patch(
                "xagent.core.tools.adapters.vibe.factory.ToolFactory"
            ) as mock_tool_factory,
        ):
            mock_resolve_llms.return_value = (MagicMock(), None, None, None)
            mock_get_memory.return_value = MagicMock()
            mock_tool_factory.create_all_tools = AsyncMock(return_value=[])
            mock_tool_factory.create_workspace_async = AsyncMock(
                return_value=MagicMock()
            )
            mock_agent_service = MagicMock()
            mock_agent_service_class.return_value = mock_agent_service

            mock_task_query = MagicMock()
            mock_task_query.filter.return_value = mock_task_query
            mock_task_query.first.return_value = owner_task
            mock_db.query.return_value = mock_task_query

            await agent_manager.get_agent_for_task(
                1,
                mock_db,
                user=admin_user,
                task_setup_snapshot=snapshot,
                task_owner_user_id=7,
                resolved_execution_scope=None,
            )

        kwargs = mock_agent_service_class.call_args.kwargs
        with patch(
            "xagent.web.services.execution_budget.resolve_execution_budget_policy",
            new_callable=AsyncMock,
            return_value=ExecutionBudgetPolicy(max_tokens=123),
        ) as resolve_budget:
            assert (await kwargs["budget_policy_provider"]()).max_tokens == 123
        request = resolve_budget.await_args.args[0]
        assert (request.user_id, request.task_id, request.scope) == (7, "1", None)
        assert kwargs["workspace_base_dir"] == str(uploads_dir / "user_7")
        assert str(uploads_dir / "user_7") in kwargs["allowed_external_dirs"]
        tool_config = kwargs["tool_config"]
        workspace_config = tool_config.get_workspace_config()
        assert tool_config.get_user_id() == 7
        assert workspace_config["base_dir"] == str(uploads_dir / "user_7")
        assert str(uploads_dir / "user_7") in workspace_config["allowed_external_dirs"]

    @pytest.mark.asyncio
    async def test_owner_voice_preference_is_applied_to_the_system_prompt(
        self, agent_manager, mock_db, tmp_path
    ):
        """End-to-end check of chat.py's own wiring (not just the
        apply_user_voice/voice_from_runtime_user units in isolation): a
        task owner with a voice preference set must get an `## OUTPUT
        VOICE` section in the AgentService's actual system_prompt."""
        owner_task = Task(
            id=1,
            user_id=7,
            title="Owner Task",
            description="Task owned by the acting user",
            status=TaskStatus.PENDING,
            agent_type="standard",
        )
        owner_user = User(
            id=7,
            username="owner",
            password_hash="hashed_password",
            is_admin=False,
        )
        snapshot = _build_reconstruction_snapshot(
            owner_task,
            owner_user,
            task_llm=MagicMock(),
            agent_config={
                "instructions": "Base instructions.",
                "knowledge_bases": [],
                "skills": [],
            },
            voice="warm",
        )
        uploads_dir = tmp_path / "uploads"

        with (
            patch(
                "xagent.web.services.agent_service_manager.AgentService"
            ) as mock_agent_service_class,
            patch(
                "xagent.web.services.llm_utils.UserAwareModelStorage.resolve_llms_from_names"
            ) as mock_resolve_llms,
            patch(
                "xagent.web.services.agent_service_manager.get_memory_store"
            ) as mock_get_memory,
            patch(
                "xagent.web.services.workspace_binding.get_uploads_dir",
                return_value=uploads_dir,
            ),
            patch(
                "xagent.core.tools.adapters.vibe.factory.ToolFactory"
            ) as mock_tool_factory,
        ):
            mock_resolve_llms.return_value = (MagicMock(), None, None, None)
            mock_get_memory.return_value = MagicMock()
            mock_tool_factory.create_all_tools = AsyncMock(return_value=[])
            mock_tool_factory.create_workspace_async = AsyncMock(
                return_value=MagicMock()
            )
            mock_agent_service = MagicMock()
            mock_agent_service_class.return_value = mock_agent_service

            mock_task_query = MagicMock()
            mock_task_query.filter.return_value = mock_task_query
            mock_task_query.first.return_value = owner_task
            mock_db.query.return_value = mock_task_query

            await agent_manager.get_agent_for_task(
                1,
                mock_db,
                user=owner_user,
                task_setup_snapshot=snapshot,
                task_owner_user_id=7,
                resolved_execution_scope=None,
            )

        system_prompt = mock_agent_service_class.call_args.kwargs["system_prompt"]
        assert system_prompt.startswith("Base instructions.\n\n## OUTPUT VOICE\n")
        assert "Empathetic and reassuring" in system_prompt

    @pytest.mark.asyncio
    async def test_voice_change_invalidates_cached_agent_on_next_turn(
        self, agent_manager, mock_db, tmp_path
    ):
        """Regression for the cache-hit gap: a cached AgentService bakes
        its system prompt in at construction time, and the per-turn
        cache-hit path (the final ``return self._agents[task_id]``) only
        re-checks owner/scope invariants, not preferences - so a voice
        PATCH would otherwise be silently ignored by an already-warm
        task. Exercises the same task through voice
        professional -> warm -> cleared, calling
        ``invalidate_cached_agents_for_owner`` between turns the way
        ``PATCH /api/auth/me/preferences`` does."""
        owner_task = Task(
            id=1,
            user_id=7,
            title="Owner Task",
            description="Task owned by the acting user",
            status=TaskStatus.PENDING,
            agent_type="standard",
        )
        owner_user = User(
            id=7,
            username="owner",
            password_hash="hashed_password",
            is_admin=False,
        )
        uploads_dir = tmp_path / "uploads"
        agent_config = {
            "instructions": "Base instructions.",
            "knowledge_bases": [],
            "skills": [],
        }

        mock_task_query = MagicMock()
        mock_task_query.filter.return_value = mock_task_query
        mock_task_query.first.return_value = owner_task
        mock_db.query.return_value = mock_task_query

        async def _turn(voice):
            snapshot = _build_reconstruction_snapshot(
                owner_task,
                owner_user,
                task_llm=MagicMock(),
                agent_config=agent_config,
                voice=voice,
            )
            await agent_manager.get_agent_for_task(
                1,
                mock_db,
                user=owner_user,
                task_setup_snapshot=snapshot,
                task_owner_user_id=7,
                resolved_execution_scope=None,
            )

        with (
            patch(
                "xagent.web.services.agent_service_manager.AgentService"
            ) as mock_agent_service_class,
            patch(
                "xagent.web.services.llm_utils.UserAwareModelStorage.resolve_llms_from_names"
            ) as mock_resolve_llms,
            patch(
                "xagent.web.services.agent_service_manager.get_memory_store"
            ) as mock_get_memory,
            patch(
                "xagent.web.services.workspace_binding.get_uploads_dir",
                return_value=uploads_dir,
            ),
            patch(
                "xagent.core.tools.adapters.vibe.factory.ToolFactory"
            ) as mock_tool_factory,
        ):
            mock_resolve_llms.return_value = (MagicMock(), None, None, None)
            mock_get_memory.return_value = MagicMock()
            mock_tool_factory.create_all_tools = AsyncMock(return_value=[])
            mock_tool_factory.create_workspace_async = AsyncMock(
                return_value=MagicMock()
            )
            mock_agent_service_class.return_value = MagicMock()
            # No execution has run on this cached instance, so invalidation
            # below must not treat it as in-flight and defer eviction.
            mock_agent_service_class.return_value.get_execution_status.return_value = (
                None
            )

            await _turn("professional")
            prompt_a = mock_agent_service_class.call_args.kwargs["system_prompt"]
            assert "Formal and polished" in prompt_a

            # A cache hit on the same task with no intervening invalidation
            # must reuse the cached instance, not rebuild.
            calls_before = mock_agent_service_class.call_count
            await _turn("professional")
            assert mock_agent_service_class.call_count == calls_before

            # Voice PATCH professional -> warm: invalidate (as the PATCH
            # endpoint does), then the next turn on the same task rebuilds
            # with the new voice.
            await agent_manager.invalidate_cached_agents_for_owner(7)
            await _turn("warm")
            prompt_b = mock_agent_service_class.call_args.kwargs["system_prompt"]
            assert "Empathetic and reassuring" in prompt_b
            assert "Formal and polished" not in prompt_b

            # Voice PATCH warm -> cleared (None): invalidate, next turn has
            # no OUTPUT VOICE section at all.
            await agent_manager.invalidate_cached_agents_for_owner(7)
            await _turn(None)
            prompt_c = mock_agent_service_class.call_args.kwargs["system_prompt"]
            assert "## OUTPUT VOICE" not in prompt_c

    @pytest.mark.asyncio
    async def test_build_tools_maps_categories_from_full_catalog(
        self, agent_manager, mock_db, sample_task, mock_user, monkeypatch
    ):
        """``_build_tools_for_task`` constructs a ``ToolSelectionSpec``
        once via ``from_raw`` and hands it to
        ``WebToolConfig.tool_selection_spec``. The factory's
        ``spec.compute_allowed_names`` dispatch then drives the
        name-level filter -- a single registry build, not a two-pass
        ``create_all_tools`` with a manual select+merge stage.
        """
        from xagent.core.tools.adapters.vibe.selection_spec import (
            _SpecByCategories,
        )

        class _Tool:
            description = ""

            def __init__(self, name: str, category: str) -> None:
                self.name = name
                self.metadata = SimpleNamespace(
                    category=SimpleNamespace(value=category)
                )

        basic_tool = _Tool("calculator", "basic")
        browser_tool = _Tool("browser_navigate", "browser")

        async def create_all_tools(
            config,
            apply_user_override_filter: bool = True,
            additional_tools=(),
        ):
            return [basic_tool, browser_tool, *additional_tools]

        monkeypatch.setattr(
            "xagent.core.tools.adapters.vibe.factory.ToolFactory.create_all_tools",
            create_all_tools,
        )

        with patch("xagent.web.sandbox_manager.get_sandbox_manager", return_value=None):
            _tools, tool_config = await agent_manager._build_tools_for_task(
                task_id=sample_task.id,
                task=sample_task,
                db=mock_db,
                user=mock_user,
                agent_config={
                    "tool_categories": ["browser"],
                    "knowledge_bases": [],
                    "skills": [],
                },
                task_llm=None,
                task_vision_llm=None,
            )

        spec = tool_config.get_tool_selection_spec()
        assert isinstance(spec, _SpecByCategories), (
            "BY_CATEGORIES mode expected for non-empty tool_categories"
        )
        assert "browser" in spec.categories

    @pytest.mark.asyncio
    async def test_build_tools_for_task_threads_voice_into_tool_config(
        self, agent_manager, mock_db, sample_task, monkeypatch
    ):
        """The owner's voice preference must reach WebToolConfig.get_voice()
        so a delegated AgentTool this task calls also honors it (see
        AgentTool.__init__'s ``voice`` param and BaseToolConfig.get_voice) -
        not just the top-level agent's own system prompt."""

        async def create_all_tools(config, apply_user_override_filter=True, **_):
            return []

        monkeypatch.setattr(
            "xagent.core.tools.adapters.vibe.factory.ToolFactory.create_all_tools",
            create_all_tools,
        )
        runtime_user = RuntimeUserFields(id=7, is_admin=False, voice="playful")

        with patch("xagent.web.sandbox_manager.get_sandbox_manager", return_value=None):
            _tools, tool_config = await agent_manager._build_tools_for_task(
                task_id=sample_task.id,
                task=sample_task,
                db=mock_db,
                user=runtime_user,
                agent_config={
                    "tool_categories": [],
                    "knowledge_bases": [],
                    "skills": [],
                },
                task_llm=None,
                task_vision_llm=None,
            )

        assert tool_config.get_voice() == "playful"

    @pytest.mark.asyncio
    @pytest.mark.parametrize(
        ("source", "expected_policy"),
        [
            ("trigger", MCPFailurePolicy.STRICT),
            ("sdk", MCPFailurePolicy.BEST_EFFORT),
            (None, MCPFailurePolicy.BEST_EFFORT),
        ],
    )
    async def test_build_tools_maps_task_source_to_mcp_failure_policy(
        self,
        source,
        expected_policy,
        agent_manager,
        mock_db,
        sample_task,
        mock_user,
        monkeypatch,
    ):
        sample_task.source = source

        async def create_all_tools(
            config,
            apply_user_override_filter=True,
            additional_tools=(),
        ):
            return list(additional_tools)

        monkeypatch.setattr(
            "xagent.core.tools.adapters.vibe.factory.ToolFactory.create_all_tools",
            create_all_tools,
        )

        task_tracer = object()
        with patch("xagent.web.sandbox_manager.get_sandbox_manager", return_value=None):
            _tools, tool_config = await agent_manager._build_tools_for_task(
                task_id=sample_task.id,
                task=sample_task,
                db=mock_db,
                user=mock_user,
                agent_config={
                    "tool_categories": ["mcp:Gmail"],
                    "knowledge_bases": [],
                    "skills": [],
                },
                task_llm=None,
                task_vision_llm=None,
                parent_tracer=task_tracer,
            )

        assert tool_config.get_mcp_failure_policy() is expected_policy
        assert tool_config._mcp_load_summary_tracer is task_tracer
        assert tool_config._mcp_load_summary_trace_task_id == str(sample_task.id)

    @pytest.mark.asyncio
    async def test_get_agent_for_task_existing_task_with_reconstruction(
        self,
        agent_manager,
        sample_task,
        sample_trace_events,
        sample_dag_execution,
        mock_user,
    ):
        """测试获取已存在任务的agent,并进行重建"""
        sample_task.status = TaskStatus.RUNNING
        runtime_llm = MagicMock()
        snapshot = _build_reconstruction_snapshot(
            sample_task,
            mock_user,
            trace_events=sample_trace_events,
            dag_execution=sample_dag_execution,
            task_llm=runtime_llm,
        )
        # 使用更高级的方法直接patch AgentService创建
        with (
            patch(
                "xagent.web.services.agent_service_manager.AgentService"
            ) as mock_agent_service_class,
            patch(
                "xagent.web.services.agent_service_manager.create_default_tools",
                new=AsyncMock(return_value=([], MagicMock())),
            ),
            patch("xagent.web.sandbox_manager.get_sandbox_manager", return_value=None),
        ):
            # 创建mock AgentService实例
            mock_agent_instance = MagicMock()
            mock_agent_instance.reconstruct_from_history = AsyncMock()
            mock_agent_service_class.return_value = mock_agent_instance

            # 调用方法
            agent = await agent_manager.get_agent_for_task(
                1,
                None,
                user=mock_user,
                task_setup_snapshot=snapshot,
            )

        # 验证结果
        assert agent is not None
        assert 1 in agent_manager._agents
        assert agent_manager._agents[1] == mock_agent_instance
        # 验证reconstruct_from_history被调用
        mock_agent_instance.reconstruct_from_history.assert_called_once()

    @pytest.mark.asyncio
    async def test_reconstruct_agent_from_history_success(
        self,
        agent_manager,
        mock_db,
        mock_user,
        sample_task,
        sample_trace_events,
        sample_dag_execution,
    ):
        """测试从历史数据重建agent成功"""
        # Mock AgentService创建和reconstruct_from_history
        runtime_llm = MagicMock()
        runtime_llm.model_name = "task-qwen"
        snapshot = _build_reconstruction_snapshot(
            sample_task,
            mock_user,
            trace_events=sample_trace_events,
            dag_execution=sample_dag_execution,
            task_llm=runtime_llm,
        )
        tool_config = MagicMock()
        tool_config.get_task_runtime_workspace.return_value = None
        with (
            patch(
                "xagent.web.services.agent_service_manager.create_default_tools",
                new=AsyncMock(return_value=(["tool"], tool_config)),
            ),
            patch("xagent.web.sandbox_manager.get_sandbox_manager", return_value=None),
            patch(
                "xagent.web.services.agent_service_manager.AgentService"
            ) as mock_agent_service_class,
        ):
            # 设置mock AgentService实例
            mock_agent_instance = MagicMock()
            mock_agent_instance.reconstruct_from_history = AsyncMock()
            mock_agent_service_class.return_value = mock_agent_instance

            # 调用方法
            await agent_manager._reconstruct_agent_from_history(
                1,
                None,
                task_setup_snapshot=snapshot,
            )

        # 验证agent被创建
        assert 1 in agent_manager._agents
        # 验证reconstruct_from_history被调用
        mock_agent_instance.reconstruct_from_history.assert_called_once()
        _, agent_kwargs = mock_agent_service_class.call_args
        with patch(
            "xagent.web.services.execution_budget.resolve_execution_budget_policy",
            new_callable=AsyncMock,
            return_value=ExecutionBudgetPolicy(max_tokens=123),
        ) as resolve_budget:
            assert (await agent_kwargs["budget_policy_provider"]()).max_tokens == 123
        request = resolve_budget.await_args.args[0]
        assert (request.user_id, request.task_id, request.scope) == (1, "1", None)
        assert agent_kwargs["tools"] == ["tool"]
        assert agent_kwargs["tool_config"] is tool_config

    @pytest.mark.asyncio
    async def test_reconstruct_agent_from_history_uses_shared_runtime_config(
        self,
        agent_manager,
        mock_db,
        mock_user,
        sample_task,
        sample_trace_events,
        sample_dag_execution,
    ):
        """Active-task reconstruction consumes the shared runtime snapshot."""
        sample_task.agent_id = 9
        runtime_llm = MagicMock()
        runtime_llm.model_name = "task-qwen"
        agent_config = {
            "instructions": "",
            "skills": [],
            "knowledge_bases": [],
        }
        snapshot = _build_reconstruction_snapshot(
            sample_task,
            mock_user,
            trace_events=sample_trace_events,
            dag_execution=sample_dag_execution,
            task_llm=runtime_llm,
            task_pattern="react",
            agent_config=agent_config,
        )
        agent_manager._resolve_task_runtime_config = MagicMock(
            side_effect=AssertionError("reconstruction re-read runtime config")
        )
        tool_config = MagicMock()
        tool_config.get_task_runtime_workspace.return_value = None

        with (
            patch(
                "xagent.web.services.agent_service_manager.create_default_tools",
                new=AsyncMock(return_value=(["tool"], tool_config)),
            ),
            patch("xagent.web.sandbox_manager.get_sandbox_manager", return_value=None),
            patch(
                "xagent.web.services.agent_service_manager.AgentService"
            ) as mock_agent_service_class,
        ):
            mock_agent_instance = MagicMock()
            mock_agent_instance.reconstruct_from_history = AsyncMock()
            mock_agent_service_class.return_value = mock_agent_instance

            await agent_manager._reconstruct_agent_from_history(
                1,
                None,
                task_setup_snapshot=snapshot,
            )

        agent_manager._resolve_task_runtime_config.assert_not_called()
        _, agent_kwargs = mock_agent_service_class.call_args
        assert agent_kwargs["llm"] is runtime_llm
        assert agent_kwargs["pattern"] == "react"

    @pytest.mark.asyncio
    async def test_reconstruct_agent_from_history_applies_owner_voice_preference(
        self,
        agent_manager,
        mock_user,
        sample_task,
        sample_trace_events,
        sample_dag_execution,
    ):
        """End-to-end check of chat.py's own wiring in the resume/reconstruct
        path (not just the apply_user_voice/voice_from_runtime_user units in
        isolation): a task whose owner has a voice preference set must get
        an `## OUTPUT VOICE` section in the AgentService's actual
        system_prompt when the agent is reconstructed from persisted
        history."""
        runtime_llm = MagicMock()
        runtime_llm.model_name = "task-qwen"
        agent_config = {
            "instructions": "Base instructions.",
            "skills": [],
            "knowledge_bases": [],
        }
        snapshot = _build_reconstruction_snapshot(
            sample_task,
            mock_user,
            trace_events=sample_trace_events,
            dag_execution=sample_dag_execution,
            task_llm=runtime_llm,
            agent_config=agent_config,
            voice="warm",
        )
        tool_config = MagicMock()
        tool_config.get_task_runtime_workspace.return_value = None

        with (
            patch(
                "xagent.web.services.agent_service_manager.create_default_tools",
                new=AsyncMock(return_value=(["tool"], tool_config)),
            ),
            patch("xagent.web.sandbox_manager.get_sandbox_manager", return_value=None),
            patch(
                "xagent.web.services.agent_service_manager.AgentService"
            ) as mock_agent_service_class,
        ):
            mock_agent_instance = MagicMock()
            mock_agent_instance.reconstruct_from_history = AsyncMock()
            mock_agent_service_class.return_value = mock_agent_instance

            await agent_manager._reconstruct_agent_from_history(
                1,
                None,
                task_setup_snapshot=snapshot,
            )

        system_prompt = mock_agent_service_class.call_args.kwargs["system_prompt"]
        assert system_prompt.startswith("Base instructions.\n\n## OUTPUT VOICE\n")
        assert "Empathetic and reassuring" in system_prompt

    @pytest.mark.asyncio
    async def test_reconstruct_agent_from_history_no_data(
        self,
        agent_manager,
        sample_task,
        mock_user,
    ):
        """测试没有历史数据时的重建"""
        snapshot = _build_reconstruction_snapshot(
            sample_task,
            mock_user,
            task_llm=MagicMock(),
        )

        # 调用方法应该抛出异常
        with pytest.raises(ValueError) as exc_info:
            await agent_manager._reconstruct_agent_from_history(
                1,
                None,
                task_setup_snapshot=snapshot,
            )

        assert "No historical data found" in str(exc_info.value)
        # 验证没有创建agent
        assert 1 not in agent_manager._agents

    @pytest.mark.asyncio
    async def test_reconstruct_agent_from_history_error_handling(self, agent_manager):
        """测试重建过程中的错误处理"""
        # 调用方法应该抛出异常
        with (
            patch(
                "xagent.web.services.agent_service_manager.load_task_setup_snapshot_sync",
                side_effect=Exception("Database error"),
            ),
            pytest.raises(Exception) as exc_info,
        ):
            await agent_manager._reconstruct_agent_from_history(1, None)

        assert "Database error" in str(exc_info.value)

    @pytest.mark.asyncio
    async def test_get_agent_for_task_snapshot_db_error_propagates(
        self, agent_manager, mock_db, mock_user
    ):
        """Snapshot DB failures do not masquerade as a missing task."""
        error = RuntimeError("Database error")

        with (
            patch(
                "xagent.web.services.agent_service_manager.load_task_setup_snapshot_sync",
                side_effect=error,
            ) as snapshot_loader,
            pytest.raises(RuntimeError) as exc_info,
        ):
            await agent_manager.get_agent_for_task(1, mock_db, user=mock_user)

        assert exc_info.value is error
        snapshot_loader.assert_called_once_with(1, None)
        mock_db.query.assert_not_called()
        assert 1 not in agent_manager._agents