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
# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
from __future__ import annotations
import asyncio
from types import SimpleNamespace
import pytest
from jiuwenswarm.server.runtime.agent_adapter import evolution_helpers
from jiuwenswarm.server.runtime.agent_adapter import interface_deep as interface_deep_module
from jiuwenswarm.server.runtime.agent_adapter.evolution_helpers import auto_rebuild_job
from jiuwenswarm.server.runtime.agent_adapter.interface_deep import JiuWenSwarmDeepAdapter
class _FakeTransport:
pushes: list[dict] = []
def __init__(self):
self.pushes = self.__class__.pushes
async def send_push(self, payload: dict) -> None:
self.pushes.append(payload)
def _approval_event(request_id: str = "team_skill_evolve_req1") -> SimpleNamespace:
return SimpleNamespace(
type="chat.ask_user_question",
payload={"request_id": request_id, "questions": [{"header": "x"}]},
)
def _outcome_event(status: str, message: str) -> SimpleNamespace:
return SimpleNamespace(
type="llm_reasoning",
payload={
"_evolution_meta": {"event_kind": "outcome", "status": status},
"content": message,
},
)
def _sdk_noop_outcome_event(skill_name: str = "powerpoint-pptx") -> SimpleNamespace:
return SimpleNamespace(
type="llm_reasoning",
payload={
"_evolution_meta": {
"event_kind": "outcome",
"rail_kind": "regular",
"status": "no_evolution_no_records",
"stage": "completed",
"skill_name": skill_name,
"source": "experience_updater",
},
"content": f"[Evolution] no applied updates for skill={skill_name}\n",
},
)
def _progress_event(
content: str,
*,
stage: str | None = None,
skill_name: str | None = None,
) -> SimpleNamespace:
payload = {"content": content}
if stage is not None:
meta: dict[str, object] = {"event_kind": "progress", "stage": stage}
if skill_name is not None:
meta["skill_name"] = skill_name
payload["_evolution_meta"] = meta
return SimpleNamespace(type="llm_reasoning", payload=payload)
class _FakeEvolutionRail:
def __init__(self, batches: list[list[object]] | None = None) -> None:
self._batches = list(
batches
if batches is not None
else [[_approval_event(), _outcome_event("completed", "done")]]
)
self.drain_waits: list[bool] = []
self.cleanup_calls = 0
self.llm_updates: list[tuple[object, str | None]] = []
def update_llm(self, model: object, model_name: str | None) -> None:
self.llm_updates.append((model, model_name))
async def drain_pending_approval_events(
self,
wait: bool = False,
timeout: float | None = None,
):
self.drain_waits.append(wait)
if self._batches:
return self._batches.pop(0)
return []
async def cleanup_background_tasks(self) -> None:
self.cleanup_calls += 1
class _FakeApprovalRail:
def __init__(
self,
*,
request_id: str = "",
record_ids: list[str] | None = None,
) -> None:
self.approved: list[tuple[str, list[str] | None]] = []
self.rejected: list[str] = []
if record_ids is not None:
self._pending_approval_snapshots = {
request_id: SimpleNamespace(
payload=[SimpleNamespace(id=record_id) for record_id in record_ids],
),
}
async def approve_record(
self,
request_id: str,
*,
approved_record_ids: list[str] | None = None,
) -> None:
self.approved.append((request_id, approved_record_ids))
async def reject_record(self, request_id: str) -> None:
self.rejected.append(request_id)
class _FakeStore:
def __init__(self, entries: list[object] | None = None) -> None:
self._entries = list(entries or [])
async def load_full_evolution_log(self, skill_name, subject_kind=None):
return SimpleNamespace(entries=list(self._entries))
class _TestAdapter(JiuWenSwarmDeepAdapter):
@classmethod
def build_with_rail(
cls,
rail: _FakeEvolutionRail,
*,
auto_save: bool = False,
evolution_entries: list[object] | None = None,
) -> "_TestAdapter":
adapter = object.__new__(cls)
setattr(adapter, "_skill_evolution_rail", rail)
setattr(
adapter,
"_config_cache",
{"react": {"evolution": {"auto_save": auto_save}}},
)
setattr(adapter, "_pending_auto_rebuild_jobs", {})
setattr(adapter, "_auto_rebuild_lock", asyncio.Lock())
setattr(adapter, "_auto_rebuild_task", None)
setattr(adapter, "_auto_evolution_generated_ids", set())
# Minimal attrs so watcher → _queue_auto_rebuild_skill →
# _should_auto_merge_evolved_skill → _resolve_skill_dirs works.
setattr(adapter, "_agent_id", "test-agent")
setattr(adapter, "_service_id", "test-service")
setattr(adapter, "_workspace_dir", ".")
setattr(adapter, "_resolve_skill_dirs", lambda extra_skill_dir=None: [])
store = _FakeStore(evolution_entries)
setattr(adapter, "_get_disk_evolution_store", lambda: store)
return adapter
async def watch_evolution_and_push(
self,
request_id: str,
channel_id: str,
session_id: str,
) -> None:
watcher = getattr(self, "_watch_evolution_and_push")
await watcher(request_id, channel_id, session_id)
@pytest.mark.asyncio
async def test_evolution_watcher_supersedes_previous_request_for_same_session(monkeypatch):
"""A resumed request replaces the paused request's old watcher ownership."""
adapter = object.__new__(JiuWenSwarmDeepAdapter)
adapter._skill_evolution_rail = object()
adapter._evolution_watcher_tasks = set()
adapter._evolution_watchers = {}
release = asyncio.Event()
started = asyncio.Event()
async def watch(request_id: str, channel_id: str, session_id: str) -> None:
started.set()
await release.wait()
monkeypatch.setattr(adapter, "_watch_evolution_and_push", watch)
first = adapter._start_evolution_watcher("rid-old", "channel-1", "session-1")
await started.wait()
started.clear()
second = adapter._start_evolution_watcher("rid-new", "channel-1", "session-1")
await started.wait()
await asyncio.sleep(0)
assert first.cancelled()
assert getattr(first, "_evolution_watcher_graceful", False) is True
assert adapter._evolution_watchers[("channel-1", "session-1")] is second
assert second in adapter._evolution_watcher_tasks
release.set()
await second
await asyncio.sleep(0)
assert ("channel-1", "session-1") not in adapter._evolution_watchers
assert second not in adapter._evolution_watcher_tasks
@pytest.mark.asyncio
async def test_cancel_evolution_watchers_does_not_cancel_skill_sleep_tasks():
"""Adapter-owned watchers are teardown-safe without changing SkillSleep lifetime."""
adapter = object.__new__(JiuWenSwarmDeepAdapter)
adapter._evolution_watcher_tasks = set()
adapter._evolution_watchers = {}
watcher_release = asyncio.Event()
sleep_release = asyncio.Event()
watcher_task = asyncio.create_task(watcher_release.wait())
sleep_task = asyncio.create_task(sleep_release.wait())
adapter._evolution_watcher_tasks.update({watcher_task, sleep_task})
adapter._evolution_watchers[("channel-1", "session-1")] = watcher_task
await adapter._cancel_evolution_watchers()
assert watcher_task.cancelled()
assert not adapter._evolution_watchers
assert sleep_task in adapter._evolution_watcher_tasks
assert not sleep_task.done()
sleep_release.set()
await sleep_task
@pytest.mark.asyncio
async def test_stream_start_does_not_cancel_inflight_route_watcher(monkeypatch):
"""A new request must not abort an in-flight prior passive evolution."""
adapter = object.__new__(JiuWenSwarmDeepAdapter)
adapter._is_session_scoped_adapter = True
adapter._instance = object()
adapter._deepresearch_rewrite_tx_uncertain = False
adapter._STALE_CRON_PERMISSION_TEXT = "stale"
async def refresh_stale_mcp_tool_lists() -> None:
return None
async def block_stale_cron_permission_resume(request) -> bool:
return True
monkeypatch.setattr(adapter, "_refresh_stale_mcp_tool_lists", refresh_stale_mcp_tool_lists)
monkeypatch.setattr(
adapter,
"_inject_extension_config_into_inputs",
lambda inputs: None,
)
monkeypatch.setattr(
interface_deep_module,
"_inject_model_selection_into_inputs",
lambda request, inputs: None,
)
monkeypatch.setattr(
interface_deep_module,
"_inject_model_routing_into_inputs",
lambda request, inputs: None,
)
monkeypatch.setattr(
interface_deep_module,
"_inject_request_id_into_inputs",
lambda request, inputs: None,
)
monkeypatch.setattr(adapter, "_has_valid_model_config", lambda model_name: True)
monkeypatch.setattr(
adapter,
"_block_stale_cron_permission_resume",
block_stale_cron_permission_resume,
)
request = SimpleNamespace(
request_id="rid-new",
channel_id="channel-1",
session_id="session-1",
params={},
metadata={},
)
chunks = [chunk async for chunk in adapter._process_message_stream_impl(request, {})]
assert chunks[-1].is_complete is True
@pytest.mark.asyncio
async def test_superseded_evolution_watcher_does_not_cancel_shared_pending_evolution(
monkeypatch,
):
"""Route handoff stops the listener without killing rail-owned evolution work."""
_FakeTransport.pushes = []
drain_release = asyncio.Event()
class _BlockingRail(_FakeEvolutionRail):
def __init__(self):
super().__init__(batches=[[]])
self.cancel_calls = 0
async def cancel_pending_evolution(self) -> None:
self.cancel_calls += 1
async def drain_pending_approval_events(self, wait=False, timeout=None):
self.drain_waits.append(wait)
await drain_release.wait()
return []
rail = _BlockingRail()
adapter = _TestAdapter.build_with_rail(rail)
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
task = asyncio.create_task(
adapter.watch_evolution_and_push("rid", "channel-1", "session-1")
)
await asyncio.sleep(0)
assert rail.drain_waits
task._evolution_watcher_graceful = True
task.cancel()
with pytest.raises(asyncio.CancelledError):
await task
assert rail.cleanup_calls == 1
assert rail.cancel_calls == 0
@pytest.mark.asyncio
async def test_active_evolution_rail_unconfigure_isolates_failures(monkeypatch):
"""One failed unregister keeps its cached reference; the other can still unload."""
adapter = object.__new__(JiuWenSwarmDeepAdapter)
active_rail = object()
interrupt_rail = object()
adapter._instance = SimpleNamespace()
adapter._skill_evolution_rail = active_rail
adapter._evolution_interrupt_rail = interrupt_rail
calls: list[object] = []
async def unregister(rail):
calls.append(rail)
if rail is active_rail:
raise RuntimeError("active rail unregister failed")
def bulk_unconfigure(instance, team=False):
return None
adapter._instance.unregister_rail = unregister
monkeypatch.setattr(interface_deep_module, "unconfigure_skill_evolution", bulk_unconfigure)
await adapter._unconfigure_active_evolution_rails()
assert calls == [active_rail, interrupt_rail]
assert adapter._skill_evolution_rail is active_rail
assert adapter._evolution_interrupt_rail is None
@pytest.mark.asyncio
async def test_skill_sleep_rail_unconfigure_keeps_cache_on_failure():
"""A failed SkillSleep unregister must not erase the still-mounted rail reference."""
adapter = object.__new__(JiuWenSwarmDeepAdapter)
rail = object()
adapter._instance = SimpleNamespace()
adapter._skill_sleep_rail = rail
adapter._skill_sleep_tasks = set()
async def unregister(unmounted_rail):
assert unmounted_rail is rail
raise RuntimeError("SkillSleep unregister failed")
adapter._instance.unregister_rail = unregister
await adapter._unconfigure_skill_sleep_rail()
assert adapter._skill_sleep_rail is rail
@pytest.mark.asyncio
async def test_cancel_evolution_watchers_cleans_registry_without_user_data():
"""Adapter teardown cancels its own in-flight watchers and empties ownership."""
adapter = object.__new__(JiuWenSwarmDeepAdapter)
adapter._evolution_watcher_tasks = set()
adapter._evolution_watchers = {}
release = asyncio.Event()
task = asyncio.create_task(release.wait())
adapter._evolution_watcher_tasks.add(task)
adapter._evolution_watchers[("channel-1", "session-1")] = task
await adapter._cancel_evolution_watchers()
with pytest.raises(asyncio.CancelledError):
await task
assert task.cancelled()
assert not adapter._evolution_watchers
assert not adapter._evolution_watcher_tasks
@pytest.mark.asyncio
async def test_normal_evolution_watcher_runs_when_rail_mounted(monkeypatch):
"""Mounted evolution rail enables passive scan; watcher does not gate on signal_trigger."""
_FakeTransport.pushes = []
rail = _FakeEvolutionRail(batches=[[]])
adapter = _TestAdapter.build_with_rail(rail)
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
monkeypatch.setattr(
interface_deep_module,
"resolve_evolution_event_timeout_sec",
lambda rail, fallback_sec=30.0: 0.01,
)
await adapter.watch_evolution_and_push("stream-rid", "web", "sess-mounted")
assert rail.drain_waits
assert rail.cleanup_calls >= 1
@pytest.mark.asyncio
async def test_normal_evolution_watcher_uses_delivery_context_metadata(monkeypatch):
_FakeTransport.pushes = []
adapter = _TestAdapter.build_with_rail(_FakeEvolutionRail())
recorded_calls: list[dict] = []
def _fake_build_server_push_message(**kwargs):
recorded_calls.append(dict(kwargs))
message = dict(kwargs)
message["channel_id"] = kwargs["fallback_channel_id"]
message["metadata"] = {"route": "from-delivery-context"}
return message
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
monkeypatch.setattr(
interface_deep_module,
"build_server_push_message",
_fake_build_server_push_message,
)
await adapter.watch_evolution_and_push("stream-rid", "web", "sess-normal")
assert recorded_calls
assert all(call["session_id"] == "sess-normal" for call in recorded_calls)
assert all(call["fallback_channel_id"] == "web" for call in recorded_calls)
assert _FakeTransport.pushes
assert all(
push["metadata"] == {"route": "from-delivery-context"}
for push in _FakeTransport.pushes
)
@pytest.mark.asyncio
async def test_normal_evolution_watcher_does_not_push_status_without_sdk_events(monkeypatch):
_FakeTransport.pushes = []
rail = _FakeEvolutionRail([])
adapter = _TestAdapter.build_with_rail(rail)
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
monkeypatch.setattr(interface_deep_module, "TEAM_EVOLUTION_IDLE_SLEEP_SEC", 0.001)
monkeypatch.setattr(interface_deep_module, "TEAM_EVOLUTION_EVENT_TIMEOUT_SEC", 0.01)
await adapter.watch_evolution_and_push("stream-rid", "web", "sess-no-events")
assert _FakeTransport.pushes == []
assert rail.drain_waits
assert rail.cleanup_calls == 1
@pytest.mark.asyncio
async def test_normal_evolution_watcher_uses_sdk_timeout_before_legacy_fallback(monkeypatch):
class _SdkTimeoutRail(_FakeEvolutionRail):
@property
def evolution_total_timeout_secs(self) -> float:
return 0.01
_FakeTransport.pushes = []
rail = _SdkTimeoutRail([[_progress_event("generating", stage="generating_updates")]])
adapter = _TestAdapter.build_with_rail(rail)
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
monkeypatch.setattr(interface_deep_module, "TEAM_EVOLUTION_IDLE_SLEEP_SEC", 0.001)
monkeypatch.setattr(interface_deep_module, "TEAM_EVOLUTION_EVENT_TIMEOUT_SEC", 100.0)
monkeypatch.setattr(evolution_helpers, "TEAM_EVOLUTION_EVENT_TIMEOUT_GRACE_SEC", 0.001)
await asyncio.wait_for(
adapter.watch_evolution_and_push("stream-rid", "web", "sess-sdk-timeout"),
timeout=0.2,
)
status_pushes = [
push for push in _FakeTransport.pushes
if push["payload"]["event_type"] == "chat.evolution_status"
]
assert [push["payload"]["status"] for push in status_pushes] == ["start", "end"]
assert status_pushes[-1]["payload"]["stage"] == "hidden"
assert rail.cleanup_calls == 1
@pytest.mark.asyncio
async def test_normal_evolution_watcher_maps_sdk_progress_stages(monkeypatch):
_FakeTransport.pushes = []
rail = _FakeEvolutionRail(
[
[_progress_event("detecting", stage="detecting_signals")],
[_progress_event("generating", stage="generating_updates")],
[_outcome_event("completed", "done")],
]
)
adapter = _TestAdapter.build_with_rail(rail)
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
await adapter.watch_evolution_and_push("stream-rid", "web", "sess-sdk-stages")
status_pushes = [
push for push in _FakeTransport.pushes
if push["payload"]["event_type"] == "chat.evolution_status"
]
assert [push["payload"]["status"] for push in status_pushes] == [
"start",
"end",
]
assert [push["payload"]["stage"] for push in status_pushes] == [
"generating",
"completed",
]
@pytest.mark.asyncio
async def test_normal_evolution_watcher_ends_on_cancelled_progress(monkeypatch):
_FakeTransport.pushes = []
rail = _FakeEvolutionRail([[_progress_event("no skill usage detected", stage="cancelled")]])
adapter = _TestAdapter.build_with_rail(rail)
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
monkeypatch.setattr(interface_deep_module, "TEAM_EVOLUTION_IDLE_SLEEP_SEC", 0.001)
monkeypatch.setattr(interface_deep_module, "TEAM_EVOLUTION_EVENT_TIMEOUT_SEC", 0.01)
await adapter.watch_evolution_and_push("stream-rid", "web", "sess-sdk-cancelled")
status_pushes = [
push for push in _FakeTransport.pushes
if push["payload"]["event_type"] == "chat.evolution_status"
]
assert status_pushes == []
assert rail.cleanup_calls == 1
@pytest.mark.asyncio
async def test_normal_evolution_watcher_does_not_start_for_no_signal_scan(monkeypatch):
_FakeTransport.pushes = []
rail = _FakeEvolutionRail(
[
[_progress_event("starting regular skill evolution review", stage="started")],
[
_progress_event(
"checking regular skill(s) for evolution signals",
stage="detecting_signals",
)
],
[
_progress_event(
"no skill usage of a regular skill or actionable evolution signal detected",
stage="cancelled",
)
],
]
)
adapter = _TestAdapter.build_with_rail(rail)
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
await adapter.watch_evolution_and_push("stream-rid", "web", "sess-no-signal-scan")
status_pushes = [
push for push in _FakeTransport.pushes
if push["payload"]["event_type"] == "chat.evolution_status"
]
assert status_pushes == []
assert rail.cleanup_calls == 1
@pytest.mark.asyncio
async def test_normal_evolution_watcher_ends_on_auto_approved_progress(monkeypatch):
_FakeTransport.pushes = []
rail = _FakeEvolutionRail([[_progress_event("auto saved", stage="auto_approved")]])
adapter = _TestAdapter.build_with_rail(rail)
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
monkeypatch.setattr(interface_deep_module, "TEAM_EVOLUTION_IDLE_SLEEP_SEC", 0.001)
monkeypatch.setattr(interface_deep_module, "TEAM_EVOLUTION_EVENT_TIMEOUT_SEC", 0.01)
await adapter.watch_evolution_and_push("stream-rid", "web", "sess-sdk-auto")
status_pushes = [
push for push in _FakeTransport.pushes
if push["payload"]["event_type"] == "chat.evolution_status"
]
assert [push["payload"]["status"] for push in status_pushes] == ["start", "end"]
assert [push["payload"]["stage"] for push in status_pushes] == [
"completed",
"completed",
]
assert rail.cleanup_calls == 1
@pytest.mark.asyncio
async def test_normal_evolution_watcher_auto_rebuilds_after_auto_approved(
monkeypatch,
):
"""selfEvolution=auto: persist (auto_approved) schedules rebuild immediately."""
_FakeTransport.pushes = []
rail = _FakeEvolutionRail(
[
[
_progress_event(
"experience records auto-saved to 'demo-skill'",
stage="auto_approved",
skill_name="demo-skill",
)
]
]
)
adapter = _TestAdapter.build_with_rail(
rail,
auto_save=True,
evolution_entries=[
SimpleNamespace(
id="ev_auto_1",
summary="auto tip",
timestamp="2026-09-17T01:00:00.000Z",
review_status="auto",
change=SimpleNamespace(summary="", content=""),
)
],
)
rebuild_calls: list[dict] = []
queued_jobs: list = []
async def _capture_rebuild(*, request_id: str | None = None) -> None:
queued_jobs.extend(adapter._pending_auto_rebuild_jobs.values()) # pylint: disable=protected-access
rebuild_calls.append({"request_id": request_id})
# Drain queue the same way production does so pending does not leak.
adapter._take_pending_auto_rebuild_jobs() # pylint: disable=protected-access
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
monkeypatch.setattr(
interface_deep_module,
"resolve_skill_evolution_action",
lambda skill_name, **_kwargs: "auto",
)
monkeypatch.setattr(adapter, "_run_auto_rebuild_skills_detached", _capture_rebuild)
monkeypatch.setattr(
interface_deep_module.evolution_version_ctl,
"resolve_subject",
lambda _store, _name: {"kind": "skill"},
)
await adapter.watch_evolution_and_push("stream-rid", "web", "sess-auto-rebuild")
await asyncio.sleep(0)
assert rebuild_calls == [{"request_id": "stream-rid"}]
assert adapter._pending_auto_rebuild_jobs == {} # pylint: disable=protected-access
assert rail.cleanup_calls == 1
generated = [
push
for push in _FakeTransport.pushes
if push.get("payload", {}).get("event_type") == "chat.evolution_generated"
]
assert len(generated) == 1
assert generated[0]["payload"]["skill_name"] == "demo-skill"
assert generated[0]["payload"]["items"][0]["id"] == "ev_auto_1"
assert [job.skill_name for job in queued_jobs] == ["demo-skill"]
assert queued_jobs[0].session_id == "sess-auto-rebuild"
assert queued_jobs[0].channel_id == "web"
assert queued_jobs[0].request_id == "stream-rid"
assert queued_jobs[0].source == "auto_watcher"
assert queued_jobs[0].push_metrics is True
@pytest.mark.asyncio
async def test_normal_evolution_watcher_auto_rebuilds_before_noop_outcome(
monkeypatch,
):
"""auto_approved schedules rebuild even if a later noop outcome arrives."""
_FakeTransport.pushes = []
rail = _FakeEvolutionRail(
[
[
_progress_event(
"experience records auto-saved to 'demo-skill'",
stage="auto_approved",
skill_name="demo-skill",
)
],
[_sdk_noop_outcome_event("demo-skill")],
]
)
adapter = _TestAdapter.build_with_rail(rail, auto_save=True)
rebuild_calls: list[dict] = []
async def _capture_rebuild(*, request_id: str | None = None) -> None:
rebuild_calls.append({"request_id": request_id})
adapter._take_pending_auto_rebuild_jobs() # pylint: disable=protected-access
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
monkeypatch.setattr(
interface_deep_module,
"resolve_skill_evolution_action",
lambda skill_name, **_kwargs: "auto",
)
monkeypatch.setattr(adapter, "_run_auto_rebuild_skills_detached", _capture_rebuild)
monkeypatch.setattr(
interface_deep_module.evolution_version_ctl,
"resolve_subject",
lambda _store, _name: {"kind": "skill"},
)
await adapter.watch_evolution_and_push("stream-rid", "web", "sess-auto-then-noop")
await asyncio.sleep(0)
assert rebuild_calls == [{"request_id": "stream-rid"}]
assert adapter._pending_auto_rebuild_jobs == {} # pylint: disable=protected-access
@pytest.mark.asyncio
async def test_evolution_watcher_timeout_schedules_pending_auto_rebuild(
monkeypatch,
):
"""Watcher timeout must flush any queued auto rebuild before exit."""
_FakeTransport.pushes = []
rail = _FakeEvolutionRail(batches=[[]])
adapter = _TestAdapter.build_with_rail(rail, auto_save=True)
adapter._pending_auto_rebuild_jobs["demo-skill"] = auto_rebuild_job( # pylint: disable=protected-access
"demo-skill",
source="auto_watcher",
session_id="sess-timeout-flush",
request_id="stream-rid",
push_metrics=True,
)
rebuild_calls: list[dict] = []
async def _capture_rebuild(*, request_id: str | None = None) -> None:
rebuild_calls.append({"request_id": request_id})
adapter._take_pending_auto_rebuild_jobs() # pylint: disable=protected-access
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
monkeypatch.setattr(
interface_deep_module,
"resolve_evolution_event_timeout_sec",
lambda rail, fallback_sec=30.0: 0.01,
)
monkeypatch.setattr(interface_deep_module, "TEAM_EVOLUTION_IDLE_SLEEP_SEC", 0.001)
monkeypatch.setattr(adapter, "_run_auto_rebuild_skills_detached", _capture_rebuild)
await adapter.watch_evolution_and_push("stream-rid", "web", "sess-timeout-flush")
await asyncio.sleep(0)
assert rebuild_calls == [{"request_id": "stream-rid"}]
assert adapter._pending_auto_rebuild_jobs == {} # pylint: disable=protected-access
assert rail.cleanup_calls >= 1
@pytest.mark.asyncio
async def test_auto_rebuild_skills_detached_pushes_published_metric(monkeypatch):
"""Auto rebuild success emits chat.evolution_published for AOM."""
_FakeTransport.pushes = []
adapter = _TestAdapter.build_with_rail(_FakeEvolutionRail(), auto_save=True)
adapter._pending_auto_rebuild_jobs["demo-skill"] = auto_rebuild_job( # pylint: disable=protected-access
"demo-skill",
source="auto_watcher",
session_id="sess-pub",
channel_id="web",
request_id="rid-pub",
push_metrics=True,
)
async def _merge(*, skill_name: str | None = None, params=None, stream_ctx=None):
return {"success": True, "name": skill_name, "new_version": "v1.3.0"}
async def _has_records(_name: str) -> bool:
return True
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
monkeypatch.setattr(
interface_deep_module,
"resolve_skill_evolution_action",
lambda skill_name, **_kwargs: "auto",
)
monkeypatch.setattr(adapter, "generate_evolution_merge_version", _merge)
monkeypatch.setattr(adapter, "_skill_has_live_evolution_records", _has_records)
await adapter._run_auto_rebuild_skills_detached(request_id="rid-pub") # pylint: disable=protected-access
published = [
push
for push in _FakeTransport.pushes
if push.get("payload", {}).get("event_type") == "chat.evolution_published"
]
assert len(published) == 1
assert published[0]["payload"]["skill_name"] == "demo-skill"
assert published[0]["payload"]["version"] == "v1.3.0"
assert published[0]["session_id"] == "sess-pub"
@pytest.mark.asyncio
async def test_auto_rebuild_published_uses_job_session_not_latest_slot(monkeypatch):
"""Each pending skill keeps the session captured at enqueue (no shared slot)."""
_FakeTransport.pushes = []
adapter = _TestAdapter.build_with_rail(_FakeEvolutionRail(), auto_save=True)
adapter._pending_auto_rebuild_jobs["skill-a"] = auto_rebuild_job( # pylint: disable=protected-access
"skill-a",
source="auto_watcher",
session_id="sess-a",
channel_id="web",
request_id="rid-a",
push_metrics=True,
)
adapter._pending_auto_rebuild_jobs["skill-b"] = auto_rebuild_job( # pylint: disable=protected-access
"skill-b",
source="auto_watcher",
session_id="sess-b",
channel_id="web",
request_id="rid-b",
push_metrics=True,
)
async def _merge(*, skill_name: str | None = None, **_kwargs):
return {"success": True, "name": skill_name, "new_version": f"v-{skill_name}"}
async def _has_records(_name: str) -> bool:
return True
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
monkeypatch.setattr(
interface_deep_module,
"resolve_skill_evolution_action",
lambda skill_name, **_kwargs: "auto",
)
monkeypatch.setattr(adapter, "generate_evolution_merge_version", _merge)
monkeypatch.setattr(adapter, "_skill_has_live_evolution_records", _has_records)
await adapter._run_auto_rebuild_skills_detached(request_id="latest-should-not-win")
published = [
push
for push in _FakeTransport.pushes
if push.get("payload", {}).get("event_type") == "chat.evolution_published"
]
by_skill = {push["payload"]["skill_name"]: push for push in published}
assert by_skill["skill-a"]["session_id"] == "sess-a"
assert by_skill["skill-b"]["session_id"] == "sess-b"
@pytest.mark.asyncio
async def test_queue_auto_rebuild_keeps_first_session_context(monkeypatch):
adapter = _TestAdapter.build_with_rail(_FakeEvolutionRail(), auto_save=True)
monkeypatch.setattr(
interface_deep_module,
"resolve_skill_evolution_action",
lambda skill_name, **_kwargs: "auto",
)
adapter._queue_auto_rebuild_skill( # pylint: disable=protected-access
"demo-skill",
source="auto_watcher",
session_id="sess-first",
channel_id="web",
request_id="rid-1",
push_metrics=True,
)
adapter._queue_auto_rebuild_skill( # pylint: disable=protected-access
"demo-skill",
source="auto_watcher",
session_id="sess-second",
channel_id="web",
request_id="rid-2",
push_metrics=True,
)
job = adapter._pending_auto_rebuild_jobs["demo-skill"] # pylint: disable=protected-access
assert job.session_id == "sess-first"
assert job.request_id == "rid-1"
@pytest.mark.asyncio
async def test_manual_approval_rebuild_does_not_push_published(monkeypatch):
_FakeTransport.pushes = []
adapter = _TestAdapter.build_with_rail(_FakeEvolutionRail(), auto_save=True)
adapter._pending_auto_rebuild_jobs["demo-skill"] = auto_rebuild_job( # pylint: disable=protected-access
"demo-skill",
source="manual_approval",
session_id="sess-manual",
channel_id="web",
request_id="rid-manual",
push_metrics=False,
)
async def _merge(*, skill_name: str | None = None, **_kwargs):
return {"success": True, "name": skill_name, "new_version": "v9.9.9"}
async def _has_records(_name: str) -> bool:
return True
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
monkeypatch.setattr(
interface_deep_module,
"resolve_skill_evolution_action",
lambda skill_name, **_kwargs: "auto",
)
monkeypatch.setattr(adapter, "generate_evolution_merge_version", _merge)
monkeypatch.setattr(adapter, "_skill_has_live_evolution_records", _has_records)
await adapter._run_auto_rebuild_skills_detached(request_id="rid-manual")
published = [
push
for push in _FakeTransport.pushes
if push.get("payload", {}).get("event_type") == "chat.evolution_published"
]
assert published == []
@pytest.mark.asyncio
async def test_generated_metrics_skip_already_reported_ids(monkeypatch):
"""Full live-log snapshots must not re-push ids already reported by this adapter."""
_FakeTransport.pushes = []
entries = [
SimpleNamespace(
id="ev_auto_1",
summary="auto tip",
timestamp="2026-09-17T01:00:00.000Z",
review_status="auto",
change=SimpleNamespace(summary="", content=""),
)
]
rail = _FakeEvolutionRail(
[
[
_progress_event(
"experience records auto-saved to 'demo-skill'",
stage="auto_approved",
skill_name="demo-skill",
)
]
]
)
adapter = _TestAdapter.build_with_rail(rail, auto_save=True, evolution_entries=entries)
async def _capture_rebuild(*, request_id: str | None = None) -> None:
adapter._take_pending_auto_rebuild_jobs() # pylint: disable=protected-access
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
monkeypatch.setattr(
interface_deep_module,
"resolve_skill_evolution_action",
lambda skill_name, **_kwargs: "auto",
)
monkeypatch.setattr(adapter, "_run_auto_rebuild_skills_detached", _capture_rebuild)
monkeypatch.setattr(
interface_deep_module.evolution_version_ctl,
"resolve_subject",
lambda _store, _name: {"kind": "skill"},
)
await adapter.watch_evolution_and_push("stream-rid-1", "web", "sess-dup")
first = [
push
for push in _FakeTransport.pushes
if push.get("payload", {}).get("event_type") == "chat.evolution_generated"
]
assert len(first) == 1
rail._batches = [
[
_progress_event(
"experience records auto-saved to 'demo-skill'",
stage="auto_approved",
skill_name="demo-skill",
)
]
]
await adapter.watch_evolution_and_push("stream-rid-2", "web", "sess-dup")
generated = [
push
for push in _FakeTransport.pushes
if push.get("payload", {}).get("event_type") == "chat.evolution_generated"
]
assert len(generated) == 1
@pytest.mark.asyncio
async def test_auto_rebuild_skills_detached_runs_serially(monkeypatch):
"""Concurrent auto-rebuild tasks serialize on the adapter lock."""
adapter = _TestAdapter.build_with_rail(_FakeEvolutionRail(), auto_save=True)
order: list[str] = []
hold = asyncio.Event()
release = asyncio.Event()
async def _slow_merge(*, skill_name: str | None = None, **_kwargs):
name = str(skill_name or "")
order.append(f"start:{name}")
if name == "skill-a":
hold.set()
await release.wait()
order.append(f"end:{name}")
return {"success": True, "name": name}
monkeypatch.setattr(
interface_deep_module,
"resolve_skill_evolution_action",
lambda skill_name, **_kwargs: "auto",
)
monkeypatch.setattr(adapter, "generate_evolution_merge_version", _slow_merge)
async def _has_records(_name: str) -> bool:
return True
monkeypatch.setattr(adapter, "_skill_has_live_evolution_records", _has_records)
adapter._pending_auto_rebuild_jobs["skill-a"] = auto_rebuild_job( # pylint: disable=protected-access
"skill-a", source="auto_watcher", session_id="sess-a", push_metrics=True
)
task_a = asyncio.create_task(
adapter._run_auto_rebuild_skills_detached(request_id="a") # pylint: disable=protected-access
)
await hold.wait()
adapter._pending_auto_rebuild_jobs["skill-b"] = auto_rebuild_job( # pylint: disable=protected-access
"skill-b", source="auto_watcher", session_id="sess-b", push_metrics=True
)
task_b = asyncio.create_task(
adapter._run_auto_rebuild_skills_detached(request_id="b") # pylint: disable=protected-access
)
await asyncio.sleep(0)
assert order == ["start:skill-a"]
release.set()
await asyncio.gather(task_a, task_b)
assert order == ["start:skill-a", "end:skill-a", "start:skill-b", "end:skill-b"]
@pytest.mark.asyncio
async def test_normal_evolution_watcher_skips_auto_rebuild_when_suggest(
monkeypatch,
):
"""selfEvolution=suggest: persisted experience must not schedule rebuild."""
_FakeTransport.pushes = []
rail = _FakeEvolutionRail(
[
[
_progress_event(
"experience records auto-saved to 'demo-skill'",
stage="auto_approved",
skill_name="demo-skill",
)
]
]
)
adapter = _TestAdapter.build_with_rail(rail, auto_save=False)
rebuild_calls: list[dict] = []
async def _capture_rebuild(*, request_id: str | None = None) -> None:
rebuild_calls.append({"request_id": request_id})
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
monkeypatch.setattr(
interface_deep_module,
"resolve_skill_evolution_action",
lambda skill_name, **_kwargs: "suggest",
)
monkeypatch.setattr(adapter, "_run_auto_rebuild_skills_detached", _capture_rebuild)
await adapter.watch_evolution_and_push("stream-rid", "web", "sess-no-auto-rebuild")
await asyncio.sleep(0)
assert rebuild_calls == []
assert adapter._pending_auto_rebuild_jobs == {} # pylint: disable=protected-access
@pytest.mark.asyncio
async def test_normal_evolution_watcher_skips_auto_rebuild_on_noop_after_generation(
monkeypatch,
):
"""selfEvolution=auto: generating then no records must not schedule rebuild."""
_FakeTransport.pushes = []
rail = _FakeEvolutionRail(
[
[_progress_event("generating", stage="generating_updates")],
[_sdk_noop_outcome_event("demo-skill")],
]
)
adapter = _TestAdapter.build_with_rail(rail, auto_save=True)
rebuild_calls: list[dict] = []
async def _capture_rebuild(*, request_id: str | None = None) -> None:
rebuild_calls.append({"request_id": request_id})
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
monkeypatch.setattr(
interface_deep_module,
"resolve_skill_evolution_action",
lambda skill_name, **_kwargs: "auto",
)
monkeypatch.setattr(adapter, "_run_auto_rebuild_skills_detached", _capture_rebuild)
await adapter.watch_evolution_and_push("stream-rid", "web", "sess-noop-no-rebuild")
await asyncio.sleep(0)
assert rebuild_calls == []
assert adapter._pending_auto_rebuild_jobs == {} # pylint: disable=protected-access
assert rail.cleanup_calls == 1
@pytest.mark.asyncio
async def test_normal_evolution_watcher_skips_auto_rebuild_on_completed_without_persist(
monkeypatch,
):
"""selfEvolution=auto: completed + skill_name without persist must not rebuild."""
_FakeTransport.pushes = []
rail = _FakeEvolutionRail(
[
[
_progress_event(
"evolution request ready for 'demo-skill'",
stage="completed",
skill_name="demo-skill",
)
]
]
)
adapter = _TestAdapter.build_with_rail(rail, auto_save=True)
rebuild_calls: list[dict] = []
async def _capture_rebuild(*, request_id: str | None = None) -> None:
rebuild_calls.append({"request_id": request_id})
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
monkeypatch.setattr(
interface_deep_module,
"resolve_skill_evolution_action",
lambda skill_name, **_kwargs: "auto",
)
monkeypatch.setattr(adapter, "_run_auto_rebuild_skills_detached", _capture_rebuild)
await adapter.watch_evolution_and_push("stream-rid", "web", "sess-completed-no-rebuild")
await asyncio.sleep(0)
assert rebuild_calls == []
assert adapter._pending_auto_rebuild_jobs == {} # pylint: disable=protected-access
@pytest.mark.asyncio
async def test_normal_evolution_watcher_reads_outcome_status_from_metadata(monkeypatch):
_FakeTransport.pushes = []
adapter = _TestAdapter.build_with_rail(
_FakeEvolutionRail([[_outcome_event("failed", "failed")]])
)
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
await adapter.watch_evolution_and_push("stream-rid", "web", "sess-normal-failed")
status_pushes = [
push for push in _FakeTransport.pushes
if push["payload"]["event_type"] == "chat.evolution_status"
]
assert status_pushes == []
@pytest.mark.asyncio
async def test_normal_evolution_watcher_hides_sdk_noop_outcome_without_prior_generation(monkeypatch):
"""Noop-only path returns before schedule; auto mode still must not queue rebuild."""
_FakeTransport.pushes = []
rail = _FakeEvolutionRail([[_sdk_noop_outcome_event("demo-skill")]])
adapter = _TestAdapter.build_with_rail(rail, auto_save=True)
rebuild_calls: list[dict] = []
async def _capture_rebuild(*, request_id: str | None = None) -> None:
rebuild_calls.append({"request_id": request_id})
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
monkeypatch.setattr(
interface_deep_module,
"resolve_skill_evolution_action",
lambda skill_name, **_kwargs: "auto",
)
monkeypatch.setattr(adapter, "_run_auto_rebuild_skills_detached", _capture_rebuild)
await adapter.watch_evolution_and_push("stream-rid", "web", "sess-sdk-noop-only")
await asyncio.sleep(0)
status_pushes = [
push for push in _FakeTransport.pushes
if push["payload"]["event_type"] == "chat.evolution_status"
]
assert status_pushes == []
assert rebuild_calls == []
assert adapter._pending_auto_rebuild_jobs == {} # pylint: disable=protected-access
assert rail.cleanup_calls == 1
@pytest.mark.asyncio
async def test_normal_evolution_watcher_ends_sdk_noop_outcome_after_generation(monkeypatch):
_FakeTransport.pushes = []
rail = _FakeEvolutionRail(
[
[_progress_event("generating", stage="generating_updates")],
[_sdk_noop_outcome_event()],
]
)
adapter = _TestAdapter.build_with_rail(rail)
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
await adapter.watch_evolution_and_push("stream-rid", "web", "sess-sdk-noop-after-generation")
status_pushes = [
push for push in _FakeTransport.pushes
if push["payload"]["event_type"] == "chat.evolution_status"
]
assert [push["payload"]["status"] for push in status_pushes] == ["start", "end"]
assert [push["payload"]["stage"] for push in status_pushes] == [
"generating",
"no_evolution_no_records",
]
assert rail.cleanup_calls == 1
@pytest.mark.asyncio
async def test_normal_evolution_watcher_does_not_push_progress_as_reasoning(monkeypatch):
_FakeTransport.pushes = []
rail = _FakeEvolutionRail(
[
[
_progress_event(
"starting regular skill evolution review for completed conversation",
stage="started",
)
],
[
_progress_event(
"checking 2 regular skill(s) for evolution signals",
stage="detecting_signals",
)
],
[_approval_event("skill_evolve_progress_req")],
]
)
adapter = _TestAdapter.build_with_rail(rail)
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
await adapter.watch_evolution_and_push("stream-rid", "web", "sess-progress")
event_types = [push["payload"]["event_type"] for push in _FakeTransport.pushes]
assert event_types == [
"chat.evolution_status",
"chat.ask_user_question",
"chat.evolution_status",
]
assert not any(
push["payload"].get("event_type") == "chat.reasoning"
for push in _FakeTransport.pushes
)
assert _FakeTransport.pushes[0]["payload"]["status"] == "start"
assert _FakeTransport.pushes[0]["payload"]["stage"] == "approval_required"
assert _FakeTransport.pushes[1]["payload"]["request_id"] == "skill_evolve_progress_req"
assert _FakeTransport.pushes[2]["payload"]["status"] == "end"
assert _FakeTransport.pushes[2]["payload"]["stage"] == "approval_required"
assert rail.cleanup_calls == 1
assert rail.drain_waits
assert set(rail.drain_waits) == {False}
@pytest.mark.asyncio
async def test_normal_evolution_watcher_times_out_after_idle_progress(monkeypatch):
_FakeTransport.pushes = []
rail = _FakeEvolutionRail([[_progress_event("evolution progress")]])
adapter = _TestAdapter.build_with_rail(rail)
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
monkeypatch.setattr(interface_deep_module, "TEAM_EVOLUTION_IDLE_SLEEP_SEC", 0.001)
monkeypatch.setattr(interface_deep_module, "TEAM_EVOLUTION_EVENT_TIMEOUT_SEC", 0.01)
await adapter.watch_evolution_and_push("stream-rid", "web", "sess-timeout")
status_pushes = [
push for push in _FakeTransport.pushes
if push["payload"]["event_type"] == "chat.evolution_status"
]
assert status_pushes == []
assert rail.cleanup_calls == 1
@pytest.mark.asyncio
async def test_normal_evolution_watcher_hides_timed_out_terminal_progress(monkeypatch):
_FakeTransport.pushes = []
adapter = _TestAdapter.build_with_rail(
_FakeEvolutionRail([[_progress_event("timed out", stage="timed_out")]])
)
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
await adapter.watch_evolution_and_push("stream-rid", "web", "sess-terminal-timeout")
status_pushes = [
push for push in _FakeTransport.pushes
if push["payload"]["event_type"] == "chat.evolution_status"
]
assert status_pushes == []
@pytest.mark.asyncio
async def test_team_skill_evolve_approval_keeps_legacy_whole_request_without_record_ids(monkeypatch):
rail = _FakeApprovalRail()
adapter = object.__new__(JiuWenSwarmDeepAdapter)
monkeypatch.setattr(
"jiuwenswarm.server.runtime.agent_adapter.interface_deep.find_team_skill_rail",
lambda request_id, channel_id=None: rail,
)
handled = await adapter.handle_team_skill_evolve_approval(
"team_skill_evolve_req1",
[{"selected_options": ["accept"]}],
session_id="sess-1",
channel_id="web",
)
assert handled is True
assert rail.approved == [("team_skill_evolve_req1", None)]
assert rail.rejected == []
@pytest.mark.asyncio
async def test_team_skill_evolve_approval_passes_selected_record_ids(monkeypatch):
rail = _FakeApprovalRail(
request_id="team_skill_evolve_req1",
record_ids=["team-rec-1", "team-rec-2", "team-rec-3"],
)
adapter = object.__new__(JiuWenSwarmDeepAdapter)
monkeypatch.setattr(
"jiuwenswarm.server.runtime.agent_adapter.interface_deep.find_team_skill_rail",
lambda request_id, channel_id=None: rail,
)
monkeypatch.setattr(
"jiuwenswarm.agents.harness.team.refresh_team_shared_skill_links_across_managers",
lambda session_id: None,
)
handled = await adapter.handle_team_skill_evolve_approval(
"team_skill_evolve_req1",
[
{"selected_options": ["accept"]},
{"selected_options": ["reject"]},
{"selected_options": ["接收"]},
],
session_id="sess-1",
channel_id="web",
)
assert handled is True
assert rail.approved == [("team_skill_evolve_req1", ["team-rec-1", "team-rec-3"])]
assert rail.rejected == []
@pytest.mark.asyncio
async def test_team_skill_evolve_approval_pushes_terminal_status(monkeypatch):
_FakeTransport.pushes = []
adapter = object.__new__(JiuWenSwarmDeepAdapter)
monkeypatch.setattr(
"jiuwenswarm.server.runtime.agent_adapter.interface_deep.find_team_skill_rail",
lambda request_id, channel_id=None: _FakeApprovalRail(),
)
monkeypatch.setattr(
"jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
_FakeTransport,
)
handled = await adapter.handle_team_skill_evolve_approval(
"team_skill_evolve_req1",
[{"selected_options": ["接收"]}],
session_id="sess-1",
channel_id="web",
)
assert handled is True
assert _FakeTransport.pushes == [
{
"session_id": "sess-1",
"request_id": "team_skill_evolve_req1",
"channel_id": "web",
"payload": {
"event_type": "chat.evolution_status",
"request_id": "team_skill_evolve_req1",
"status": "end",
"stage": "completed",
"message": "Team skill evolution accepted",
},
}
]