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
from __future__ import annotations
import asyncio
from unittest.mock import AsyncMock, MagicMock, patch
import pytest
from jiuwenswarm.agents.harness.common.tools.deepresearch_task_manager import (
DeepResearchManagerClosedError,
DeepResearchTaskManager,
DeepResearchTaskManagerPool,
)
from jiuwenswarm.common.local_env_config import (
bind_task_env_overlay,
reset_task_env_overlay,
)
from jiuwenswarm.server.runtime.runtime_scope import RuntimeScopeKey
def _process(*, returncode=None, wait_side_effect=None):
process = MagicMock()
process.returncode = returncode
if wait_side_effect is None:
process.wait = AsyncMock(return_value=0)
else:
process.wait = AsyncMock(side_effect=wait_side_effect)
return process
class _LifecycleProcess:
def __init__(
self,
pid: int,
*,
terminate_error: BaseException | None = None,
kill_error: BaseException | None = None,
wait_results: list[BaseException | int] | None = None,
) -> None:
self.pid = pid
self.returncode = None
self.terminate_error = terminate_error
self.kill_error = kill_error
self.wait_results = list(wait_results or [0])
self.calls: list[str] = []
def terminate(self) -> None:
self.calls.append("terminate")
if self.terminate_error is not None:
raise self.terminate_error
def kill(self) -> None:
self.calls.append("kill")
if self.kill_error is not None:
raise self.kill_error
async def wait(self) -> int:
self.calls.append("wait")
result = self.wait_results.pop(0)
if isinstance(result, BaseException):
raise result
self.returncode = result
return result
class _BlockingWaitProcess(_LifecycleProcess):
def __init__(self, pid: int) -> None:
super().__init__(pid)
self.wait_started = asyncio.Event()
self.release_wait = asyncio.Event()
async def wait(self) -> int:
self.calls.append("wait")
self.wait_started.set()
await self.release_wait.wait()
self.returncode = 0
return 0
class _NeverExitsProcess(_LifecycleProcess):
async def wait(self) -> int:
self.calls.append("wait")
await asyncio.Event().wait()
raise AssertionError("unreachable")
class _CancelDuringFirstWaitProcess(_LifecycleProcess):
def __init__(self, pid: int) -> None:
super().__init__(pid)
self.first_wait_started = asyncio.Event()
async def wait(self) -> int:
self.calls.append("wait")
if self.calls.count("wait") == 1:
self.first_wait_started.set()
await asyncio.Event().wait()
raise AssertionError("unreachable")
self.returncode = 0
return 0
def test_manager_normalizes_tenant_and_tracks_process_sets_by_session():
manager = DeepResearchTaskManager(service_id=" ", agent_id="\t")
first = _process()
second = _process()
manager.track_process("session-a", first)
manager.track_process("session-a", second)
manager.track_process("session-b", first)
assert manager.service_id == "default"
assert manager.agent_id == "default"
assert manager._processes == {
"session-a": {first, second},
"session-b": {first},
}
manager.untrack_process("session-a", first)
assert manager._processes["session-a"] == {second}
manager.untrack_process("session-a", second)
assert "session-a" not in manager._processes
manager.untrack_process("session-a", second)
manager.untrack_process("missing-session", first)
def test_pool_isolates_runtime_scopes_by_workspace_key():
DeepResearchTaskManagerPool.reset_for_tests()
try:
workspace_a = RuntimeScopeKey.from_ids(
"svc",
"agent",
workspace_key="workspace-a",
)
workspace_b = RuntimeScopeKey.from_ids(
"svc",
"agent",
workspace_key="workspace-b",
)
manager_a = DeepResearchTaskManagerPool.get_or_create_sync(workspace_a)
manager_b = DeepResearchTaskManagerPool.get_or_create_sync(workspace_b)
assert manager_a is not manager_b
assert DeepResearchTaskManagerPool.get_or_create_sync(workspace_a) is manager_a
assert DeepResearchTaskManagerPool.get_or_create_sync(workspace_b) is manager_b
finally:
DeepResearchTaskManagerPool.reset_for_tests()
def test_shutdown_terminates_active_processes_across_sessions_and_clears_registry():
manager = DeepResearchTaskManager(service_id="svc", agent_id="agent")
first = _process()
second = _process()
exited = _process(returncode=0)
manager.track_process("session-a", first)
manager.track_process("session-b", second)
manager.track_process("session-b", exited)
asyncio.run(manager.shutdown(timeout=0.01))
first.terminate.assert_called_once_with()
second.terminate.assert_called_once_with()
first.wait.assert_awaited_once()
second.wait.assert_awaited_once()
first.kill.assert_not_called()
second.kill.assert_not_called()
exited.terminate.assert_not_called()
exited.kill.assert_not_called()
exited.wait.assert_not_awaited()
assert manager._processes == {}
def test_shutdown_stops_same_process_registered_in_multiple_sessions_once():
manager = DeepResearchTaskManager()
process = _process()
manager.track_process("session-a", process)
manager.track_process("session-b", process)
asyncio.run(manager.shutdown(timeout=0.01))
process.terminate.assert_called_once_with()
process.wait.assert_awaited_once()
process.kill.assert_not_called()
assert manager._processes == {}
def test_shutdown_finishes_child_cleanup_before_propagating_cancellation():
manager = DeepResearchTaskManager()
process = _CancelDuringFirstWaitProcess(601)
manager.track_process("session", process)
async def _run() -> None:
shutdown_task = asyncio.create_task(manager.shutdown(timeout=0.01))
await process.first_wait_started.wait()
shutdown_task.cancel()
await asyncio.wait_for(shutdown_task, timeout=0.1)
with pytest.raises(asyncio.CancelledError):
asyncio.run(_run())
assert process.calls == ["terminate", "wait", "kill", "wait"]
assert manager._processes == {}
assert manager._closing is True
def test_shutdown_resists_repeated_cancellation_until_child_cleanup_finishes():
manager = DeepResearchTaskManager()
process = _CancelDuringFirstWaitProcess(602)
manager.track_process("session", process)
async def _run() -> None:
cancel_handler_waiting = asyncio.Event()
original_shield = asyncio.shield
async def _observed_shield(awaitable):
try:
return await original_shield(awaitable)
except asyncio.CancelledError:
cancel_handler_waiting.set()
raise
with patch(
"jiuwenswarm.agents.harness.common.tools."
"deepresearch_task_manager.asyncio.shield",
new=_observed_shield,
):
shutdown_task = asyncio.create_task(manager.shutdown(timeout=0.01))
await process.first_wait_started.wait()
shutdown_task.cancel()
await cancel_handler_waiting.wait()
shutdown_task.cancel()
await asyncio.wait_for(shutdown_task, timeout=0.1)
with pytest.raises(asyncio.CancelledError):
asyncio.run(_run())
assert process.calls == ["terminate", "wait", "kill", "wait"]
assert manager._processes == {}
assert manager._closing is True
def test_shutdown_kills_process_after_terminate_wait_timeout():
manager = DeepResearchTaskManager()
process = _process(wait_side_effect=[asyncio.TimeoutError, 0])
manager.track_process("session", process)
asyncio.run(manager.shutdown(timeout=0.01))
process.terminate.assert_called_once_with()
process.kill.assert_called_once_with()
assert process.wait.await_count == 2
assert manager._processes == {}
def test_shutdown_continues_after_terminate_process_lookup():
manager = DeepResearchTaskManager()
missing = _LifecycleProcess(101, terminate_error=ProcessLookupError())
survivor = _LifecycleProcess(102)
manager.track_process("first", missing)
manager.track_process("second", survivor)
asyncio.run(manager.shutdown(timeout=0.01))
assert missing.calls == ["terminate"]
assert survivor.calls == ["terminate", "wait"]
assert manager._processes == {}
def test_shutdown_continues_after_kill_process_lookup():
manager = DeepResearchTaskManager()
missing = _LifecycleProcess(
201,
kill_error=ProcessLookupError(),
wait_results=[asyncio.TimeoutError()],
)
survivor = _LifecycleProcess(202)
manager.track_process("first", missing)
manager.track_process("second", survivor)
asyncio.run(manager.shutdown(timeout=0.01))
assert missing.calls == ["terminate", "wait", "kill"]
assert survivor.calls == ["terminate", "wait"]
assert manager._processes == {}
def test_shutdown_continues_after_second_wait_timeout():
manager = DeepResearchTaskManager()
stuck = _NeverExitsProcess(301)
survivor = _LifecycleProcess(302)
manager.track_process("first", stuck)
manager.track_process("second", survivor)
asyncio.run(asyncio.wait_for(manager.shutdown(timeout=0.01), timeout=0.1))
assert stuck.calls == ["terminate", "wait", "kill", "wait"]
assert survivor.calls == ["terminate", "wait"]
assert manager._processes == {}
def test_shutdown_logs_unexpected_cleanup_error_and_continues():
manager = DeepResearchTaskManager()
broken = _LifecycleProcess(401, terminate_error=RuntimeError("do-not-log-this"))
survivor = _LifecycleProcess(402)
manager.track_process("first", broken)
manager.track_process("second", survivor)
with patch(
"jiuwenswarm.agents.harness.common.tools.deepresearch_task_manager.logger.warning"
) as warning:
asyncio.run(manager.shutdown(timeout=0.01))
assert broken.calls == ["terminate"]
assert survivor.calls == ["terminate", "wait"]
warning.assert_called_once()
warning_args = warning.call_args.args
assert warning_args[1:] == ("terminate", "RuntimeError", 401)
assert "do-not-log-this" not in repr(warning.call_args)
assert manager._processes == {}
def test_shutdown_rejects_late_registration_and_never_reopens():
manager = DeepResearchTaskManager()
active = _BlockingWaitProcess(501)
late = _LifecycleProcess(502)
manager.track_process("active", active)
async def _run() -> tuple[BaseException | None, BaseException | None]:
shutdown_task = asyncio.create_task(manager.shutdown(timeout=0.1))
await active.wait_started.wait()
try:
manager.track_process("late", late)
except DeepResearchManagerClosedError as exc:
first_error = exc
else:
first_error = None
active.release_wait.set()
await shutdown_task
await manager.shutdown(timeout=0.1)
try:
manager.track_process("later", late)
except DeepResearchManagerClosedError as exc:
second_error = exc
else:
second_error = None
return first_error, second_error
first_error, second_error = asyncio.run(_run())
for error in (first_error, second_error):
assert isinstance(error, DeepResearchManagerClosedError)
assert str(error) == "deepresearch_manager_closed"
assert active.calls == ["terminate", "wait"]
assert late.calls == []
assert manager._processes == {}
def test_load_config_prefers_detected_bocha_and_explicit_petal():
from jiuwenswarm.agents.harness.common.tools.deepresearch_task_manager import (
load_deepresearch_config,
)
common = {
"MODEL_NAME": "global-model",
"MODEL_PROVIDER": "openai",
"API_BASE": "https://maas.example/v2/",
"API_KEY": "global-key",
"BOCHA_API_KEY": "bocha-key",
}
detected = load_deepresearch_config(common)
assert detected["WEB_SEARCH_ENGINE_NAME"] == "bocha"
assert detected["WEB_SEARCH_API_KEY"] == "bocha-key"
explicit_petal = load_deepresearch_config(
{
**common,
"WEB_SEARCH_ENGINE_NAME": "petal",
"PETAL_API_KEY": "petal-key",
}
)
assert explicit_petal["WEB_SEARCH_ENGINE_NAME"] == "petal"
assert explicit_petal["WEB_SEARCH_API_KEY"] == "petal-key"
assert explicit_petal["WEB_SEARCH_URL"] == (
"https://maas.example/v1/ai-tools/web-search"
)
def test_explicit_petal_snapshot_never_reads_bound_tenant_overlay():
from jiuwenswarm.agents.harness.common.tools.deepresearch_task_manager import (
load_deepresearch_config,
)
tenant_a_url = "https://tenant-a.example/search?token=tenant-a-secret"
snapshot_b_url = "https://tenant-b.example/search?token=snapshot-b-token"
snapshot_b = {
"MODEL_NAME": "snapshot-model",
"MODEL_PROVIDER": "openai",
"API_BASE": "https://snapshot-b.example/v2",
"API_KEY": "snapshot-model-key",
"PETAL_SEARCH_URL": snapshot_b_url,
"PETAL_SEARCH_HEADERS": '{"Authorization":"snapshot-b-header"}',
}
token = bind_task_env_overlay(
{
"PETAL_SEARCH_URL": tenant_a_url,
"PETAL_SEARCH_HEADERS": '{"Authorization":"tenant-a-header"}',
}
)
try:
detected = DeepResearchTaskManager._detect_configured_search_engines(snapshot_b)
loaded = load_deepresearch_config(snapshot_b)
finally:
reset_task_env_overlay(token)
assert detected == {"petal": snapshot_b_url}
assert loaded["WEB_SEARCH_ENGINE_NAME"] == "petal"
assert loaded["WEB_SEARCH_API_KEY"] == snapshot_b_url
assert tenant_a_url not in repr((detected, loaded))
def test_load_config_passes_model_name_through_unchanged():
"""模型名原样透传给隔离子进程(不做任何翻译)。"""
from jiuwenswarm.agents.harness.common.tools.deepresearch_task_manager import (
load_deepresearch_config,
)
base = {"API_BASE": "https://maas.example/v2/", "API_KEY": "k"}
assert load_deepresearch_config({**base, "MODEL_NAME": "glm-5.2"})["LLM_MODEL_NAME"] == "glm-5.2"
assert load_deepresearch_config({**base, "MODEL_NAME": "deepseek-v4.1-flash"})["LLM_MODEL_NAME"] == (
"deepseek-v4.1-flash"
)
# 显式 LLM_MODEL_NAME 优先。
assert load_deepresearch_config({**base, "LLM_MODEL_NAME": "glm-5.2", "MODEL_NAME": "deepseek-v4.1-flash"})[
"LLM_MODEL_NAME"
] == "glm-5.2"
@pytest.mark.parametrize(
("text", "expected"),
[
(
'{"sections":[{"title":"背景"},{"name":"趋势"}]}',
{"1": "背景", "2": "趋势"},
),
(
"# 深度研究报告:主题\n## 第1章:背景\n### 2. 趋势\n## 结论",
{"1": "背景", "2": "趋势", "3": "结论"},
),
(
"# 大纲:用户需求洞察报告\n"
"## 页面规划\n"
"### P1: 用户画像构建(重点)\n"
"### P2: 行为习惯分析(重点)\n"
"### P3: 真实痛点挖掘(重点)\n"
"### P4: 消费决策逻辑剖析(重点)\n"
"### P5: 潜在需求识别与产品设计建议(重点)",
{
"1": "用户画像构建(重点)",
"2": "行为习惯分析(重点)",
"3": "真实痛点挖掘(重点)",
"4": "消费决策逻辑剖析(重点)",
"5": "潜在需求识别与产品设计建议(重点)",
},
),
],
)
def test_extract_deepresearch_section_titles(text, expected):
from jiuwenswarm.agents.harness.common.tools.deepresearch_task_manager import (
extract_deepresearch_section_titles,
)
assert extract_deepresearch_section_titles(text) == expected