sync update from LAN repo (source master-yx @ cf505220)

This commit is contained in:
gozeros committed 2026-10-21 15:11:11 +08:00
1 parent e243ec3a46
commit 19d3cb96dc
114 files changed
+14787 -451

No files matched your search

@@ -11,9 +11,11 @@ import asyncio
from types import SimpleNamespace
import httpx
from langchain_core.messages import AIMessage
import pytest
from langchain_core.messages import AIMessage, AIMessageChunk
from deerflow.agents.middlewares.llm_error_handling_middleware import LLM_ERROR_MARKER, LLMErrorHandlingMiddleware
from deerflow.models.patched_openai import OpenAICompatibleUpstreamError, PatchedChatOpenAI
def _middleware() -> LLMErrorHandlingMiddleware:
@@ -26,6 +28,10 @@ def _middleware() -> LLMErrorHandlingMiddleware:
return middleware
def _openai_model() -> PatchedChatOpenAI:
return PatchedChatOpenAI(model="test-model", api_key="test-key")
def test_httpx_read_timeout_is_transient() -> None:
assert _middleware()._classify_error(httpx.ReadTimeout("read timed out")) == (True, "transient")
@@ -46,6 +52,98 @@ def test_value_error_stays_generic() -> None:
assert _middleware()._classify_error(ValueError("boom")) == (False, "generic")
def test_openai_compatible_embedded_error_is_retriable_upstream() -> None:
error = RuntimeError("OpenAI-compatible upstream application error (code=2056)")
assert _middleware()._classify_error(error) == (True, "upstream")
def test_openai_compatible_null_choices_error_is_retriable_upstream() -> None:
error = TypeError("Received response with null value for 'choices'.")
assert _middleware()._classify_error(error) == (True, "upstream")
def test_insufficient_balance_stays_non_retriable_quota() -> None:
"""The 200-body compatibility fix must not hide a real billing failure."""
class PaymentError(RuntimeError):
status_code = 402
error = PaymentError("Insufficient Balance")
assert _middleware()._classify_error(error) == (False, "quota")
def test_minimax_token_plan_limit_stays_non_retriable_quota() -> None:
error = OpenAICompatibleUpstreamError(
code=2056,
message="Token Plan limit reached",
)
assert _middleware()._classify_error(error) == (False, "quota")
def test_non_stream_embedded_application_error_is_raised() -> None:
response = {
"id": "failed-response",
"object": "chat.completion",
"created": 0,
"model": "test-model",
"choices": None,
"base_resp": {
"status_code": 2056,
"status_msg": "Token Plan limit reached",
},
}
with pytest.raises(OpenAICompatibleUpstreamError, match=r"code=2056") as exc_info:
_openai_model()._create_chat_result(response)
assert exc_info.value.code == 2056
assert "Token Plan limit reached" in str(exc_info.value)
def test_stream_embedded_application_error_is_raised() -> None:
chunk = {
"id": "failed-response",
"object": "chat.completion.chunk",
"created": 0,
"model": "test-model",
"choices": [],
"base_resp": {
"status_code": 2056,
"status_msg": "Token Plan limit reached",
},
}
with pytest.raises(OpenAICompatibleUpstreamError, match=r"code=2056"):
_openai_model()._convert_chunk_to_generation_chunk(chunk, AIMessageChunk, None)
def test_normal_empty_usage_chunk_is_not_treated_as_error() -> None:
chunk = {
"id": "usage-response",
"object": "chat.completion.chunk",
"created": 0,
"model": "test-model",
"choices": [],
"usage": {
"prompt_tokens": 3,
"completion_tokens": 2,
"total_tokens": 5,
},
}
result = _openai_model()._convert_chunk_to_generation_chunk(chunk, AIMessageChunk, None)
assert result is not None
assert result.message.usage_metadata == {
"input_tokens": 3,
"output_tokens": 2,
"total_tokens": 5,
"input_token_details": {},
"output_token_details": {},
}
def test_read_timeout_is_retried_and_recovers() -> None:
"""第一次 ReadTimeout、第二次成功:必须重试并返回真实结果。"""
middleware = _middleware()
@@ -0,0 +1,283 @@
from __future__ import annotations
import asyncio
from pathlib import Path
from threading import Event
from types import SimpleNamespace
import pytest
import yaml
from fastapi import FastAPI
from starlette.requests import Request
from app.gateway import llmwiki_index_runtime
from app.gateway.routers import llmwiki_index
from deerflow.config.llmwiki_config import LocalWikiEmbeddingConfig, LocalWikiIndexConfig
from deerflow.config.system_settings import LocalWikiEncoderSettings, SystemSettings
from deerflow.integrations.weknora.local_index.embedding import StrictWikiEmbeddingClient, WikiEmbeddingError
def _source_config(embedding: LocalWikiEmbeddingConfig):
return SimpleNamespace(
llmwiki=SimpleNamespace(
local_wiki_index=LocalWikiIndexConfig(enabled=True, embedding=embedding)
)
)
def test_runtime_mode_can_switch_remote_config_to_uploaded_local_model(tmp_path: Path) -> None:
configured = LocalWikiEmbeddingConfig(
provider="openai_compatible",
model="remote-embedding",
base_url="https://embedding.example.test/v1",
dimensions=1536,
)
source = _source_config(configured)
normal = llmwiki_index_runtime.resolve_effective_local_wiki_index_config(
source,
LocalWikiEncoderSettings(mode="configured"),
)
assert normal.embedding.provider == "openai_compatible"
assert normal.embedding.model == "remote-embedding"
assert normal.embedding.dimensions == 1536
local = llmwiki_index_runtime.resolve_effective_local_wiki_index_config(
source,
LocalWikiEncoderSettings(
mode="local",
model_path=str(tmp_path),
model_revision="revision-2",
),
)
assert local.embedding.provider == "local"
assert local.embedding.model == "bge-embedding-m3"
assert local.embedding.dimensions == 1024
assert local.embedding.local_model_path == str(tmp_path)
assert local.embedding.local_model_revision == "revision-2"
assert local.embedding.base_url == ""
assert local.embedding.api_key == ""
def test_local_model_revision_changes_embedding_fingerprint(tmp_path: Path) -> None:
common = {
"provider": "local",
"model": "bge-embedding-m3",
"dimensions": 1024,
"local_model_path": str(tmp_path),
}
first = StrictWikiEmbeddingClient(
LocalWikiEmbeddingConfig(**common, local_model_revision="first")
)
second = StrictWikiEmbeddingClient(
LocalWikiEmbeddingConfig(**common, local_model_revision="second")
)
assert first.fingerprint != second.fingerprint
def test_local_model_path_changes_embedding_fingerprint(tmp_path: Path) -> None:
first_path = tmp_path / "revision-a"
second_path = tmp_path / "revision-b"
common = {
"provider": "local",
"model": "bge-embedding-m3",
"dimensions": 1024,
"local_model_revision": "same-revision",
}
first = StrictWikiEmbeddingClient(
LocalWikiEmbeddingConfig(**common, local_model_path=str(first_path))
)
second = StrictWikiEmbeddingClient(
LocalWikiEmbeddingConfig(**common, local_model_path=str(second_path))
)
assert first.fingerprint != second.fingerprint
def test_uploaded_local_mode_always_uses_bge_m3_contract(tmp_path: Path) -> None:
configured = LocalWikiEmbeddingConfig(
provider="local",
model="another-local-model",
local_model_path=str(tmp_path / "configured"),
dimensions=384,
)
effective = llmwiki_index_runtime.resolve_effective_local_wiki_index_config(
_source_config(configured),
LocalWikiEncoderSettings(
mode="local",
model_path=str(tmp_path / "uploaded"),
model_revision="uploaded-revision",
),
)
assert effective.embedding.provider == "local"
assert effective.embedding.model == "bge-embedding-m3"
assert effective.embedding.dimensions == 1024
assert effective.embedding.local_model_path == str(tmp_path / "uploaded")
def test_local_provider_never_uses_residual_base_url_as_readiness(tmp_path: Path) -> None:
config = LocalWikiIndexConfig(
enabled=True,
embedding=LocalWikiEmbeddingConfig(
provider="local",
model="bge-embedding-m3",
local_model_path=str(tmp_path / "missing"),
base_url="https://stale.example.test/v1",
dimensions=1024,
),
)
assert llmwiki_index_runtime._embedding_provider_ready(config) is False
@pytest.mark.asyncio
async def test_retired_embedding_rejects_future_work() -> None:
client = StrictWikiEmbeddingClient(
LocalWikiEmbeddingConfig(
provider="openai",
model="text-embedding-3-small",
base_url="https://api.openai.com/v1",
dimensions=1536,
)
)
await client.retire()
with pytest.raises(WikiEmbeddingError) as exc_info:
await client.embed_query("retry me")
assert getattr(exc_info.value, "category", None) == "runtime_retired"
@pytest.mark.asyncio
async def test_cancelled_local_embedding_drains_worker_thread_before_releasing_lock(
monkeypatch,
) -> None:
client = StrictWikiEmbeddingClient(
LocalWikiEmbeddingConfig(
provider="local",
model="bge-embedding-m3",
dimensions=2,
)
)
started = Event()
release = Event()
def blocking_embed(_texts):
started.set()
release.wait(timeout=5)
return [[1.0, 0.0]]
monkeypatch.setattr(client, "_embed_local", blocking_embed)
embedding_task = asyncio.create_task(client.embed_texts(["text"]))
assert await asyncio.to_thread(started.wait, 1)
embedding_task.cancel()
await asyncio.sleep(0)
assert not embedding_task.done()
assert client._active_uses == 1
embedding_task.cancel()
await asyncio.sleep(0)
assert not embedding_task.done()
assert client._active_uses == 1
release.set()
with pytest.raises(asyncio.CancelledError):
await embedding_task
assert client._active_uses == 0
@pytest.mark.asyncio
async def test_status_is_available_for_remote_provider(monkeypatch) -> None:
configured = LocalWikiEmbeddingConfig(
provider="openai",
model="text-embedding-3-small",
base_url="https://api.openai.com/v1",
dimensions=1536,
)
app = FastAPI()
app.state.config = _source_config(configured)
app.state.llmwiki_effective_config = app.state.config.llmwiki.local_wiki_index
app.state.llmwiki_embedding = StrictWikiEmbeddingClient(configured)
request = Request({"type": "http", "headers": [], "app": app})
async def admin(_request):
return "admin", True
async def unchanged(_app, *, force=False):
return _app.state.llmwiki_effective_config
monkeypatch.setattr(llmwiki_index, "_actor", admin)
monkeypatch.setattr(llmwiki_index, "rebuild_local_wiki_index_runtime", unchanged)
monkeypatch.setattr(
llmwiki_index_runtime,
"load_system_settings",
lambda: SystemSettings(
local_wiki_encoder=LocalWikiEncoderSettings(mode="configured")
),
)
result = await llmwiki_index.local_encoder_status(request)
assert result["provider"] == "openai"
assert result["configured_provider"] == "openai"
assert result["mode"] == "configured"
assert result["using_local"] is False
assert result["state"] == "idle"
@pytest.mark.asyncio
async def test_local_path_save_and_restore_persist_mode_and_rebuild(
monkeypatch,
tmp_path: Path,
) -> None:
model_dir = tmp_path / "bge-m3"
(model_dir / "onnx").mkdir(parents=True)
(model_dir / "onnx" / "model.onnx").write_bytes(b"onnx")
app = FastAPI()
request = Request({"type": "http", "headers": [], "app": app})
saved: list[SystemSettings] = []
current = SystemSettings()
rebuilds: list[bool] = []
async def admin(_request):
return "admin", True
async def rebuilt(_app, *, force=False):
rebuilds.append(force)
return LocalWikiIndexConfig()
monkeypatch.setattr(llmwiki_index, "_actor", admin)
monkeypatch.setattr(llmwiki_index, "load_system_settings", lambda: saved[-1] if saved else current)
monkeypatch.setattr(llmwiki_index, "save_system_settings", lambda value: saved.append(value) or value)
monkeypatch.setattr(llmwiki_index, "rebuild_local_wiki_index_runtime", rebuilt)
monkeypatch.setattr(
llmwiki_index,
"local_encoder_runtime_status",
lambda _app: {
"provider": "local" if saved[-1].local_wiki_encoder.mode == "local" else "openai",
"mode": saved[-1].local_wiki_encoder.mode,
},
)
local = await llmwiki_index.configure_local_encoder(
request,
llmwiki_index.LocalEncoderConfigRequest(model_path=str(model_dir)),
)
assert local["mode"] == "local"
assert saved[-1].local_wiki_encoder.mode == "local"
assert saved[-1].local_wiki_encoder.model_revision
configured = await llmwiki_index.use_configured_encoder(request)
assert configured["mode"] == "configured"
assert saved[-1].local_wiki_encoder.mode == "configured"
assert rebuilds == [True, True]
def test_both_shipped_offline_configs_enable_incremental_wiki_rescan() -> None:
offline_root = Path(__file__).resolve().parents[2]
for path in (offline_root / "config.yaml", offline_root / "backend" / "config.yaml"):
payload = yaml.safe_load(path.read_text(encoding="utf-8"))
local_index = payload["llmwiki"]["local_wiki_index"]
assert local_index["enabled"] is True
assert local_index["auto_sync"] is True
@@ -497,6 +497,129 @@ async def test_weknora_client_resolves_default_embedding_model_inside_weknora()
assert created["id"] == "kb-created"
@pytest.mark.asyncio
async def test_gateway_lists_safe_embedding_models_and_uses_explicit_selection(
monkeypatch: pytest.MonkeyPatch,
) -> None:
from app.gateway.routers import llmwiki as llmwiki_router
create_calls: list[dict[str, object]] = []
class Client:
async def list_models(self) -> list[dict[str, object]]:
return [
{
"id": "embed-local",
"type": "Embedding",
"name": "Local BGE",
"provider": "local",
"status": "active",
"is_default": True,
"api_key": "must-not-leak",
"config": {"secret": "must-not-leak"},
},
{
"id": "embed-openai",
"type": "embedding",
"display_name": "OpenAI text-embedding",
"source": "remote",
"parameters": {
"model": "text-embedding-3-large",
"provider": "openai",
"api_key": "must-not-leak",
},
"status": "active",
},
{
"id": "embed-disabled",
"type": "Embedding",
"name": "Disabled",
"status": "inactive",
},
{"id": "chat-one", "type": "LLM", "name": "chat"},
]
async def create_knowledge_base(self, **kwargs: object) -> dict[str, object]:
create_calls.append(kwargs)
return {
"id": "remote-openai",
"name": kwargs["name"],
"description": kwargs["description"],
"type": kwargs["kb_type"],
"embedding_model_id": kwargs["embedding_model_id"],
}
async def actor(_: object) -> tuple[str, bool]:
return "user-a", False
store = MemoryLlmWikiStore()
client = Client()
monkeypatch.setattr(llmwiki_router, "_actor", actor)
monkeypatch.setattr(llmwiki_router, "_client_or_503", lambda: client)
monkeypatch.setattr(llmwiki_router, "_store", lambda _: store)
monkeypatch.setattr(llmwiki_router, "_schedule_local_wiki_sync", lambda *_: None)
listed = await llmwiki_router.list_embedding_models(object())
assert listed["default_model_id"] == "embed-local"
assert [item["id"] for item in listed["models"]] == [
"embed-local",
"embed-openai",
"embed-disabled",
]
assert listed["models"][1]["provider"] == "openai"
assert listed["models"][1]["model_name"] == "text-embedding-3-large"
assert listed["models"][2]["available"] is False
assert "api_key" not in listed["models"][0]
assert "config" not in listed["models"][0]
assert "parameters" not in listed["models"][1]
created = await llmwiki_router.create_knowledge_base(
object(),
llmwiki_router.KnowledgeBaseCreate(
name="OpenAI docs",
embedding_model_id="embed-openai",
),
)
assert create_calls[0]["embedding_model_id"] == "embed-openai"
assert created["embedding_model_id"] == "embed-openai"
for rejected_model_id in ("embed-disabled", "chat-one", "missing"):
with pytest.raises(HTTPException) as exc_info:
await llmwiki_router.create_knowledge_base(
object(),
llmwiki_router.KnowledgeBaseCreate(
name="Rejected docs",
embedding_model_id=rejected_model_id,
),
)
assert exc_info.value.status_code == 422
assert len(create_calls) == 1
@pytest.mark.asyncio
async def test_gateway_embedding_model_list_allows_empty_configuration(
monkeypatch: pytest.MonkeyPatch,
) -> None:
from app.gateway.routers import llmwiki as llmwiki_router
class Client:
async def list_models(self) -> list[dict[str, object]]:
return [{"id": "chat-only", "type": "LLM"}]
async def actor(_: object) -> tuple[str, bool]:
return "user-a", False
monkeypatch.setattr(llmwiki_router, "_actor", actor)
monkeypatch.setattr(llmwiki_router, "_client_or_503", lambda: Client())
assert await llmwiki_router.list_embedding_models(object()) == {
"models": [],
"default_model_id": None,
}
@pytest.mark.asyncio
async def test_weknora_client_creates_wiki_with_weknora_owned_models() -> None:
model_reads = 0
@@ -199,34 +199,101 @@ async def test_fingerprint_change_automatically_rebuilds_entire_mapping() -> Non
@pytest.mark.asyncio
async def test_auto_sync_scheduler_scans_immediately_then_waits(monkeypatch) -> None:
calls: list[str] = []
async def test_auto_sync_scheduler_scans_immediately_then_only_when_due(monkeypatch) -> None:
now = 0.0
refreshes: list[float] = []
syncs: list[float] = []
sleeps: list[float] = []
config = SimpleNamespace(
enabled=True,
auto_sync=True,
sync_interval_seconds=25,
)
async def fake_refresh(_app):
refreshes.append(now)
return config
async def fake_sleep(seconds: float) -> None:
calls.append(f"sleep:{seconds}")
raise asyncio.CancelledError
async def fake_sync_once(app) -> None:
calls.append("sync")
if calls.count("sync") > 1:
nonlocal now
sleeps.append(seconds)
if len(syncs) >= 2:
raise asyncio.CancelledError
now += seconds
async def fake_sync_once(_app, *, config=None) -> None:
syncs.append(now)
monkeypatch.setattr(llmwiki_index_scheduler, "monotonic", lambda: now)
monkeypatch.setattr(llmwiki_index_scheduler.asyncio, "sleep", fake_sleep)
monkeypatch.setattr(llmwiki_index_scheduler, "_sync_once", fake_sync_once)
monkeypatch.setattr(
llmwiki_index_scheduler,
"_refresh_local_wiki_config",
fake_refresh,
)
app = SimpleNamespace(
state=SimpleNamespace(
config=SimpleNamespace(
llmwiki=SimpleNamespace(
local_wiki_index=SimpleNamespace(sync_interval_seconds=120),
)
)
llmwiki_sync_service=object(),
llmwiki_store=object(),
)
)
with pytest.raises(asyncio.CancelledError):
await llmwiki_index_scheduler.local_wiki_index_scheduler_loop(app)
assert calls == ["sync", "sleep:120"]
assert refreshes == [0.0, 10.0, 20.0, 30.0]
assert syncs == [0.0, 30.0]
assert sleeps == [10.0, 10.0, 10.0, 10.0]
@pytest.mark.asyncio
async def test_auto_sync_scheduler_refreshes_provider_between_syncs(monkeypatch) -> None:
now = 0.0
seen_providers: list[str] = []
syncs: list[str] = []
providers = iter(("openai", "local", "local"))
async def fake_refresh(_app):
provider = next(providers)
seen_providers.append(provider)
_app.state.llmwiki_runtime_signature = provider
return SimpleNamespace(
enabled=True,
auto_sync=True,
sync_interval_seconds=120,
embedding=SimpleNamespace(provider=provider),
)
async def fake_sync_once(_app, *, config=None) -> None:
syncs.append(config.embedding.provider)
async def fake_sleep(seconds: float) -> None:
nonlocal now
now += seconds
if len(seen_providers) >= 3:
raise asyncio.CancelledError
monkeypatch.setattr(llmwiki_index_scheduler, "monotonic", lambda: now)
monkeypatch.setattr(llmwiki_index_scheduler.asyncio, "sleep", fake_sleep)
monkeypatch.setattr(llmwiki_index_scheduler, "_sync_once", fake_sync_once)
monkeypatch.setattr(
llmwiki_index_scheduler,
"_refresh_local_wiki_config",
fake_refresh,
)
app = SimpleNamespace(
state=SimpleNamespace(
llmwiki_sync_service=object(),
llmwiki_store=object(),
)
)
with pytest.raises(asyncio.CancelledError):
await llmwiki_index_scheduler.local_wiki_index_scheduler_loop(app)
assert seen_providers == ["openai", "local", "local"]
assert syncs == ["openai", "local"]
def test_local_wiki_index_defaults_to_automatic_sync() -> None:
@@ -13,14 +13,20 @@
from __future__ import annotations
import asyncio
import json
from contextlib import asynccontextmanager
from types import SimpleNamespace
import pytest
import app.gateway.roundtable_model_fallback as mf
import app.gateway.routers.parallel_agents as parallel_agents
from app.gateway.roundtable_model_fallback import (
fallback_model_chain,
is_llm_error_message,
reason_text,
)
from app.gateway.routers._strategy_selection_seed import default_strategy_agent_roles
from deerflow.agents.middlewares.llm_error_handling_middleware import (
LLM_ERROR_MARKER,
LLMErrorHandlingMiddleware,
@@ -56,6 +62,520 @@ def test_is_llm_error_message_normal_is_none() -> None:
assert is_llm_error_message({"type": "ai", "content": ""}) is None
def test_parallel_agent_run_raises_instead_of_completing_llm_fallback(monkeypatch) -> None:
fallback_message = {
"type": "ai",
"content": "大模型本次调用未能成功完成,请稍后再试或更换模型。",
}
async def fake_stream_upstream(*_args, **_kwargs):
yield None, [f"data: {json.dumps({'messages': [fallback_message]}, ensure_ascii=False)}"]
monkeypatch.setattr(parallel_agents, "_stream_upstream", fake_stream_upstream)
async def collect() -> list[object]:
return [
item
async for item in parallel_agents._run_one_agent(
None, # type: ignore[arg-type]
"http://gateway.test",
{"Authorization": "Bearer test"},
"strategy-selection-intent",
"thread-id",
"test task",
"",
)
]
try:
asyncio.run(collect())
except RuntimeError as exc:
assert "模型调用失败" in str(exc)
else:
raise AssertionError("LLM fallback message must not be emitted as agent_done")
def test_parallel_agent_run_rejects_punctuation_only_delivery(monkeypatch) -> None:
invalid_message = {"type": "ai", "content": "!" * 500}
async def fake_stream_upstream(*_args, **_kwargs):
yield None, [f"data: {json.dumps({'messages': [invalid_message]}, ensure_ascii=False)}"]
monkeypatch.setattr(parallel_agents, "_stream_upstream", fake_stream_upstream)
async def collect() -> list[object]:
return [
item
async for item in parallel_agents._run_one_agent(
None, # type: ignore[arg-type]
"http://gateway.test",
{"Authorization": "Bearer test"},
"strategy-selection-angle-security",
"thread-id",
"test task",
"",
)
]
try:
asyncio.run(collect())
except RuntimeError as exc:
assert "未生成有效正文" in str(exc)
else:
raise AssertionError("Punctuation-only output must not be emitted as agent_done")
def test_parallel_agent_run_allows_empty_content_clarification(monkeypatch) -> None:
clarification_message = {
"type": "ai",
"content": "",
"tool_calls": [
{
"id": "clarify-1",
"name": "ask_clarification",
"args": {
"question": "请确认策略时间范围。",
"clarification_type": "single_choice",
"options": ["短期", "长期"],
"allow_custom": True,
},
}
],
}
async def fake_stream_upstream(*_args, **_kwargs):
yield None, [f"data: {json.dumps({'messages': [clarification_message]}, ensure_ascii=False)}"]
monkeypatch.setattr(parallel_agents, "_stream_upstream", fake_stream_upstream)
async def collect() -> list[object]:
return [
item
async for item in parallel_agents._run_one_agent(
None, # type: ignore[arg-type]
"http://gateway.test",
{"Authorization": "Bearer test"},
"strategy-selection-intent",
"thread-id",
"test task",
"",
)
]
events = asyncio.run(collect())
assert len(events) == 1
event = events[0]
assert isinstance(event, dict)
assert event["type"] == "clarification"
assert event["content"] == ""
assert event["clarification"]["question"] == "请确认策略时间范围。"
def test_parallel_agent_final_values_keep_typed_reasoning_out_of_content(monkeypatch) -> None:
final_message = {
"type": "ai",
"content": [
{"type": "thinking", "text": "核对约束与证据"},
{"type": "text", "text": "这是最终可见策略正文,包含目标、路径和验收标准。"},
],
}
async def fake_stream_upstream(*_args, **_kwargs):
yield None, [f"data: {json.dumps({'messages': [final_message]}, ensure_ascii=False)}"]
monkeypatch.setattr(parallel_agents, "_stream_upstream", fake_stream_upstream)
async def collect() -> list[object]:
return [
item
async for item in parallel_agents._run_one_agent(
None, # type: ignore[arg-type]
"http://gateway.test",
{"Authorization": "Bearer test"},
"strategy-selection-angle-security",
"thread-id",
"test task",
"",
)
]
events = asyncio.run(collect())
assert len(events) == 1
event = events[0]
assert isinstance(event, dict)
assert event["content"] == "这是最终可见策略正文,包含目标、路径和验收标准。"
assert event["reasoning"] == "核对约束与证据"
def test_parallel_agent_final_values_recovers_template_injected_reasoning(monkeypatch) -> None:
final_message = {
"type": "ai",
"content": "模板注入的内部推理</think>这是最终可见策略正文,包含目标、路径和验收标准。",
}
async def fake_stream_upstream(*_args, **_kwargs):
yield None, [f"data: {json.dumps({'messages': [final_message]}, ensure_ascii=False)}"]
monkeypatch.setattr(parallel_agents, "_stream_upstream", fake_stream_upstream)
async def collect() -> list[object]:
return [
item
async for item in parallel_agents._run_one_agent(
None, # type: ignore[arg-type]
"http://gateway.test",
{"Authorization": "Bearer test"},
"strategy-selection-angle-security",
"thread-id",
"test task",
"",
)
]
events = asyncio.run(collect())
event = events[0]
assert isinstance(event, dict)
assert event["content"] == "这是最终可见策略正文,包含目标、路径和验收标准。"
assert event["reasoning"] == "模板注入的内部推理"
def test_parallel_agent_substantive_content_accepts_chinese_and_english() -> None:
assert parallel_agents._has_substantive_content("这是一份包含目标、前置条件、阶段路径和验收标准的完整策略。")
assert parallel_agents._has_substantive_content("A complete strategy with objectives, prerequisites, milestones, and measurable outcomes.")
assert not parallel_agents._has_substantive_content("<think>internal reasoning only</think>!!!")
def test_parallel_agent_extracts_provider_reasoning_without_mixing_answer() -> None:
answer, reasoning = parallel_agents._extract_ai_stream_parts(
{
"type": "AIMessageChunk",
"content": [
{"type": "thinking_delta", "text": "先核对边界"},
{"type": "text", "text": "可见正文"},
],
"additional_kwargs": {"reasoning_content": ",再比较路径"},
}
)
assert answer == "可见正文"
assert reasoning == "先核对边界,再比较路径"
answer, reasoning = parallel_agents._extract_ai_stream_parts(
{
"type": "AIMessageChunk",
"content": [
{"type": "thinking", "thinking": "结构化思考字段"},
{"type": "text", "text": "最终正文"},
],
}
)
assert answer == "最终正文"
assert reasoning == "结构化思考字段"
class _EnabledStrategyRoleStore:
async def ensure_defaults(self, _rows) -> int:
return 0
async def list_roles(self, *, include_disabled: bool) -> list[dict[str, object]]:
del include_disabled
return [dict(row) for row in default_strategy_agent_roles()]
async def get_role(self, agent_id: str) -> dict[str, object]:
return {"id": agent_id, "enabled": True}
class _GlobalStrategyAgentStore:
async def get_any(self, agent_id: str) -> dict[str, object]:
return {"id": agent_id, "user_id": None}
def _parallel_request() -> SimpleNamespace:
return SimpleNamespace(
app=SimpleNamespace(
state=SimpleNamespace(
strategy_agent_role_store=_EnabledStrategyRoleStore(),
agent_store=_GlobalStrategyAgentStore(),
)
)
)
def test_parallel_agent_stream_separates_inline_and_provider_reasoning(monkeypatch) -> None:
async def fake_run_one_agent(*_args, **_kwargs):
yield "event: messages"
yield f"data: {json.dumps([{'type': 'ai', 'content': '<thi'}], ensure_ascii=False)}"
yield "event: messages"
yield f"data: {json.dumps([{'type': 'ai', 'content': 'nk>内部分析</think>方案正文'}], ensure_ascii=False)}"
yield "event: messages"
yield f"data: {json.dumps([{'type': 'ai', 'content': '', 'additional_kwargs': {'reasoning_content': '补充推理'}}], ensure_ascii=False)}"
yield {
"status": "done",
"content": "<think>内部分析</think>方案正文",
"agent_name": "strategy-selection-angle-security",
"tool_calls": [],
}
@asynccontextmanager
async def fake_client(*_args, **_kwargs):
yield object()
async def fake_create_thread(*_args, **_kwargs):
return "thread-id"
monkeypatch.setattr(parallel_agents, "_run_one_agent", fake_run_one_agent)
monkeypatch.setattr(parallel_agents, "_make_loopback_client", fake_client)
monkeypatch.setattr(parallel_agents, "_create_thread", fake_create_thread)
monkeypatch.setattr(parallel_agents, "_loopback_base", lambda _request: "http://gateway.test")
monkeypatch.setattr(parallel_agents, "_auth_headers", lambda _request: {})
async def collect() -> list[dict[str, object]]:
response = await parallel_agents.run_parallel_agents_stream(
_parallel_request(),
{
"task_name": "test task",
"brief": "test brief",
"agent_ids": ["strategy-selection-angle-security"],
},
)
events: list[dict[str, object]] = []
async for chunk in response.body_iterator:
text = chunk.decode() if isinstance(chunk, bytes) else chunk
for line in text.splitlines():
if line.startswith("data:"):
events.append(json.loads(line[5:].strip()))
return events
events = asyncio.run(collect())
visible = "".join(str(event.get("text") or "") for event in events if event.get("type") == "delta")
thinking = "".join(str(event.get("text") or "") for event in events if event.get("type") == "reasoning_delta")
done = next(event for event in events if event.get("type") == "agent_done")
assert visible == "方案正文"
assert thinking == "内部分析补充推理"
assert done["content"] == "方案正文"
@pytest.mark.parametrize(
("buffered_content", "expected_error"),
[
("大模型本次调用未能成功完成,请稍后再试或更换模型。", "模型调用失败"),
("", "未生成有效正文"),
("<think>internal reasoning only</think>", "未生成有效正文"),
("!" * 500, "未生成有效正文"),
],
)
def test_parallel_agent_truncated_stream_rejects_invalid_buffer(
monkeypatch,
buffered_content: str,
expected_error: str,
) -> None:
async def fake_run_one_agent(*_args, **_kwargs):
yield "event: messages"
yield f"data: {json.dumps([{'type': 'ai', 'content': buffered_content}], ensure_ascii=False)}"
@asynccontextmanager
async def fake_client(*_args, **_kwargs):
yield object()
async def fake_create_thread(*_args, **_kwargs):
return "thread-id"
monkeypatch.setattr(parallel_agents, "_run_one_agent", fake_run_one_agent)
monkeypatch.setattr(parallel_agents, "_make_loopback_client", fake_client)
monkeypatch.setattr(parallel_agents, "_create_thread", fake_create_thread)
monkeypatch.setattr(parallel_agents, "_loopback_base", lambda _request: "http://gateway.test")
monkeypatch.setattr(parallel_agents, "_auth_headers", lambda _request: {})
async def collect() -> list[dict[str, object]]:
response = await parallel_agents.run_parallel_agents_stream(
_parallel_request(),
{
"task_name": "test task",
"brief": "test brief",
"agent_ids": ["strategy-selection-intent"],
},
)
events: list[dict[str, object]] = []
async for chunk in response.body_iterator:
text = chunk.decode() if isinstance(chunk, bytes) else chunk
for line in text.splitlines():
if line.startswith("data:"):
events.append(json.loads(line[5:].strip()))
return events
events = asyncio.run(collect())
assert not any(event.get("type") == "agent_done" for event in events)
errors = [event for event in events if event.get("type") == "agent_error"]
assert len(errors) == 1
assert expected_error in str(errors[0].get("message"))
def test_parallel_agent_plain_text_streams_each_chunk_without_probe_delay(
monkeypatch,
) -> None:
chunks = [
"This visible strategy ",
"includes objectives and execution paths, ",
"plus measurable acceptance criteria.",
]
async def fake_run_one_agent(*_args, **_kwargs):
for content in chunks:
yield "event: messages"
yield f"data: {json.dumps([{'type': 'ai', 'content': content}], ensure_ascii=False)}"
@asynccontextmanager
async def fake_client(*_args, **_kwargs):
yield object()
async def fake_create_thread(*_args, **_kwargs):
return "thread-id"
monkeypatch.setattr(parallel_agents, "_run_one_agent", fake_run_one_agent)
monkeypatch.setattr(parallel_agents, "_make_loopback_client", fake_client)
monkeypatch.setattr(parallel_agents, "_create_thread", fake_create_thread)
monkeypatch.setattr(
parallel_agents,
"_loopback_base",
lambda _request: "http://gateway.test",
)
monkeypatch.setattr(parallel_agents, "_auth_headers", lambda _request: {})
monkeypatch.setattr(
parallel_agents,
"_should_probe_implicit_reasoning",
lambda *_args: False,
)
async def collect() -> list[dict[str, object]]:
response = await parallel_agents.run_parallel_agents_stream(
_parallel_request(),
{
"task_name": "plain stream",
"brief": "plain answer chunks must stay live",
"agent_ids": ["strategy-selection-intent"],
},
)
events: list[dict[str, object]] = []
async for chunk in response.body_iterator:
text = chunk.decode() if isinstance(chunk, bytes) else chunk
for line in text.splitlines():
if line.startswith("data:"):
events.append(json.loads(line[5:].strip()))
return events
events = asyncio.run(collect())
assert [event["text"] for event in events if event.get("type") == "delta"] == chunks
done = next(event for event in events if event.get("type") == "agent_done")
assert done["content"] == "".join(chunks)
def test_parallel_agent_typed_reasoning_unlocks_live_answer_channel(monkeypatch) -> None:
chunks = [
"This visible strategy ",
"streams after typed reasoning, ",
"with objectives and acceptance criteria.",
]
async def fake_run_one_agent(*_args, **_kwargs):
yield "event: messages"
yield f"data: {json.dumps([{'type': 'ai', 'content': '', 'additional_kwargs': {'reasoning_content': 'live reasoning'}}])}"
for content in chunks:
yield "event: messages"
yield f"data: {json.dumps([{'type': 'ai', 'content': content}])}"
@asynccontextmanager
async def fake_client(*_args, **_kwargs):
yield object()
async def fake_create_thread(*_args, **_kwargs):
return "thread-id"
monkeypatch.setattr(parallel_agents, "_run_one_agent", fake_run_one_agent)
monkeypatch.setattr(parallel_agents, "_make_loopback_client", fake_client)
monkeypatch.setattr(parallel_agents, "_create_thread", fake_create_thread)
monkeypatch.setattr(parallel_agents, "_loopback_base", lambda _request: "http://gateway.test")
monkeypatch.setattr(parallel_agents, "_auth_headers", lambda _request: {})
monkeypatch.setattr(parallel_agents, "_should_probe_implicit_reasoning", lambda *_args: True)
async def collect() -> list[dict[str, object]]:
response = await parallel_agents.run_parallel_agents_stream(
_parallel_request(),
{
"task_name": "typed reasoning stream",
"brief": "answer chunks must stay live",
"agent_ids": ["strategy-selection-intent"],
},
)
events: list[dict[str, object]] = []
async for chunk in response.body_iterator:
text = chunk.decode() if isinstance(chunk, bytes) else chunk
for line in text.splitlines():
if line.startswith("data:"):
events.append(json.loads(line[5:].strip()))
return events
events = asyncio.run(collect())
assert [event["text"] for event in events if event.get("type") == "delta"] == chunks
assert "".join(str(event.get("text") or "") for event in events if event.get("type") == "reasoning_delta") == "live reasoning"
def test_parallel_agent_truncated_close_only_stream_separates_reasoning(monkeypatch) -> None:
async def fake_run_one_agent(*_args, **_kwargs):
yield "event: messages"
yield f"data: {json.dumps([{'type': 'ai', 'content': 'internal '}], ensure_ascii=False)}"
yield "event: messages"
yield f"data: {json.dumps([{'type': 'ai', 'content': 'reasoning</thi'}], ensure_ascii=False)}"
yield "event: messages"
yield f"data: {json.dumps([{'type': 'ai', 'content': 'nk>This visible strategy includes objectives, execution paths, and acceptance criteria.'}], ensure_ascii=False)}"
@asynccontextmanager
async def fake_client(*_args, **_kwargs):
yield object()
async def fake_create_thread(*_args, **_kwargs):
return "thread-id"
monkeypatch.setattr(parallel_agents, "_run_one_agent", fake_run_one_agent)
monkeypatch.setattr(parallel_agents, "_make_loopback_client", fake_client)
monkeypatch.setattr(parallel_agents, "_create_thread", fake_create_thread)
monkeypatch.setattr(parallel_agents, "_loopback_base", lambda _request: "http://gateway.test")
monkeypatch.setattr(parallel_agents, "_auth_headers", lambda _request: {})
monkeypatch.setattr(
parallel_agents,
"_should_probe_implicit_reasoning",
lambda *_args: True,
)
async def collect() -> list[dict[str, object]]:
response = await parallel_agents.run_parallel_agents_stream(
_parallel_request(),
{
"task_name": "test task",
"brief": "test brief",
"agent_ids": ["strategy-selection-intent"],
},
)
events: list[dict[str, object]] = []
async for chunk in response.body_iterator:
text = chunk.decode() if isinstance(chunk, bytes) else chunk
for line in text.splitlines():
if line.startswith("data:"):
events.append(json.loads(line[5:].strip()))
return events
events = asyncio.run(collect())
done = next(event for event in events if event.get("type") == "agent_done")
reasoning = "".join(str(event.get("text") or "") for event in events if event.get("type") == "reasoning_delta")
visible = "".join(str(event.get("text") or "") for event in events if event.get("type") == "delta")
assert done["content"] == ("This visible strategy includes objectives, execution paths, and acceptance criteria.")
assert visible == done["content"]
assert reasoning == "internal reasoning"
# ── 中间件给兜底 AIMessage 打标记 ────────────────────────────────────────────
@@ -0,0 +1,46 @@
from __future__ import annotations
from pathlib import Path
from deerflow.config.app_config import AppConfig
def test_relative_sandbox_mount_is_resolved_from_config_directory(tmp_path: Path) -> None:
knowledge_dir = tmp_path / "knowledge" / "knowledge_base"
knowledge_dir.mkdir(parents=True)
config_path = tmp_path / "config.yaml"
config_path.write_text(
"""
sandbox:
use: deerflow.sandbox.local:LocalSandboxProvider
mounts:
- host_path: knowledge/knowledge_base
container_path: /mnt/knowledge
read_only: true
""".strip(),
encoding="utf-8",
)
config = AppConfig.from_file(str(config_path))
assert config.sandbox.mounts[0].host_path == str(knowledge_dir.resolve())
assert Path(config.sandbox.mounts[0].host_path).is_absolute()
def test_absolute_sandbox_mount_is_preserved(tmp_path: Path) -> None:
absolute_mount = (tmp_path / "shared").resolve()
config_data = {
"sandbox": {
"use": "deerflow.sandbox.local:LocalSandboxProvider",
"mounts": [
{
"host_path": str(absolute_mount),
"container_path": "/mnt/shared",
}
],
}
}
AppConfig._resolve_relative_mount_paths(config_data, tmp_path / "elsewhere")
assert config_data["sandbox"]["mounts"][0]["host_path"] == str(absolute_mount)
@@ -0,0 +1,667 @@
"""Global strategy-agent role CRUD, permissions and visibility tests."""
from __future__ import annotations
import asyncio
from pathlib import Path
from types import SimpleNamespace
import pytest
import yaml
from fastapi import HTTPException
from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
from app.gateway.routers import _strategy_selection_seed as seed
from app.gateway.routers import agents as agents_router
from app.gateway.routers import parallel_agents, strategy_agents
from deerflow.config import agents_config
from deerflow.config.paths import Paths
from deerflow.persistence.agents import MemoryAgentStore
from deerflow.persistence.skills.memory import MemorySkillStore
from deerflow.persistence.strategy_agent_roles import MemoryStrategyAgentRoleStore, StrategyAgentRoleRepository
from deerflow.persistence.strategy_agent_roles.model import StrategyAgentRoleRow
from deerflow.skills.types import Skill, SkillCategory
class _SkillStorage:
def __init__(self, skills: list[Skill]) -> None:
self._skills = skills
def load_skills(self, *, enabled_only: bool) -> list[Skill]:
if enabled_only:
return [skill for skill in self._skills if skill.enabled]
return list(self._skills)
def _skill(name: str, category: SkillCategory = SkillCategory.PUBLIC) -> Skill:
directory = Path("skills") / category.value / name
return Skill(
name=name,
description=name,
license=None,
skill_dir=directory,
skill_file=directory / "SKILL.md",
relative_path=Path(name),
category=category,
enabled=True,
)
def test_generic_agent_namespace_guard_is_case_insensitive_and_canonical() -> None:
assert agents_router._is_strategy_agent_id("STRATEGY-SELECTION-INTENT")
assert strategy_agents._process_lock("STRATEGY-SELECTION-INTENT") is strategy_agents._process_lock("strategy-selection-intent")
with pytest.raises(HTTPException) as exc_info:
agents_router._require_canonical_record_id(
"STRATEGY-SELECTION-INTENT",
{"id": "strategy-selection-intent"},
)
assert exc_info.value.status_code == 409
@pytest.mark.asyncio
async def test_generic_mutations_reject_strategy_namespace_before_storage(
monkeypatch: pytest.MonkeyPatch,
) -> None:
monkeypatch.setattr(
agents_router,
"get_agents_api_config",
lambda: SimpleNamespace(enabled=True),
)
request = SimpleNamespace()
with pytest.raises(HTTPException) as update_error:
await agents_router.update_agent(
seed.STRATEGY_INTENT_AGENT_ID.upper(),
agents_router.AgentUpdateRequest(name="bypass"),
request,
)
assert update_error.value.status_code == 409
assert "/api/strategy-agents/" in str(update_error.value.detail)
with pytest.raises(HTTPException) as delete_error:
await agents_router.delete_agent(
seed.STRATEGY_INTENT_AGENT_ID.upper(),
request,
)
assert delete_error.value.status_code == 409
assert "generic API" in str(delete_error.value.detail)
@pytest.mark.asyncio
async def test_strategy_mutation_rejects_case_insensitive_database_alias(
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
) -> None:
request, agent_store, role_store = await _request(tmp_path, monkeypatch)
canonical_id = seed.STRATEGY_INTENT_AGENT_ID
await role_store.ensure_defaults(seed.default_strategy_agent_roles())
role = await role_store.get_role(canonical_id)
record = await agent_store.get_any(canonical_id)
assert role is not None and record is not None
monkeypatch.setattr(strategy_agents, "_ensure_registry", lambda *_: _async_none())
monkeypatch.setattr(role_store, "get_role", lambda _: _async_value(role))
monkeypatch.setattr(agent_store, "get_any", lambda _: _async_value(record))
with pytest.raises(HTTPException) as exc_info:
await strategy_agents._get_role_and_agent(request, canonical_id.upper())
assert exc_info.value.status_code == 409
async def _async_none() -> None:
return None
async def _async_value(value):
return value
async def _request(
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
*,
role: str = "admin",
) -> tuple[SimpleNamespace, MemoryAgentStore, MemoryStrategyAgentRoleStore]:
paths = Paths(tmp_path)
monkeypatch.setattr(seed, "get_paths", lambda: paths)
monkeypatch.setattr(agents_router, "get_paths", lambda: paths)
monkeypatch.setattr(strategy_agents, "get_paths", lambda: paths)
monkeypatch.setattr(agents_config, "get_paths", lambda: paths)
seed.ensure_strategy_selection_agents()
agent_store = MemoryAgentStore()
for agent_id in seed.required_agent_ids():
config = yaml.safe_load((paths.agent_dir(agent_id) / "config.yaml").read_text(encoding="utf-8"))
await agent_store.ensure_builtin(
{
"id": agent_id,
"name": config["name"],
"description": config.get("description") or "",
"published": True,
}
)
role_store = MemoryStrategyAgentRoleStore()
skill_store = MemorySkillStore()
storage = _SkillStorage(
[
_skill("public-skill"),
_skill("published-custom", SkillCategory.CUSTOM),
_skill("private-custom", SkillCategory.CUSTOM),
]
)
await skill_store.create(
{
"name": "published-custom",
"owner_user_id": "publisher",
"published": True,
}
)
await skill_store.create(
{
"name": "private-custom",
"owner_user_id": "owner",
"published": False,
}
)
monkeypatch.setattr(agents_router, "get_or_new_skill_storage", lambda **_: storage)
monkeypatch.setattr(agents_router, "get_skill_usage_entries", lambda: {})
state = SimpleNamespace(
agent_store=agent_store,
strategy_agent_role_store=role_store,
skill_store=skill_store,
config=SimpleNamespace(models=[SimpleNamespace(name="model-a")]),
)
request = SimpleNamespace(
app=SimpleNamespace(state=state),
state=SimpleNamespace(
user=SimpleNamespace(id="actor", system_role=role),
),
)
return request, agent_store, role_store
@pytest.mark.asyncio
async def test_catalog_has_fixed_categories_and_redacts_public_config(
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
) -> None:
request, _, role_store = await _request(tmp_path, monkeypatch)
public = await strategy_agents.list_strategy_agents(request)
assert len(public.agents) == 9
assert [(item.category, item.fixed) for item in public.agents if item.fixed] == [
("intent", True),
("judge", True),
("solution", True),
]
assert all(item.model is None and item.soul is None and item.skills is None for item in public.agents)
await role_store.update_role(seed.STRATEGY_SECURITY_AGENT_ID, enabled=False)
active = await strategy_agents.list_strategy_agents(request)
assert seed.STRATEGY_SECURITY_AGENT_ID not in {item.id for item in active.agents}
admin = await strategy_agents.list_strategy_agents(
request,
include_disabled=True,
include_config=True,
)
disabled = next(item for item in admin.agents if item.id == seed.STRATEGY_SECURITY_AGENT_ID)
assert disabled.enabled is False
assert disabled.soul
assert disabled.skills == ["policy-knowledge"]
@pytest.mark.asyncio
async def test_catalog_rejects_user_owned_reserved_default(
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
) -> None:
request, agent_store, _ = await _request(tmp_path, monkeypatch)
await agent_store.delete_builtin(seed.STRATEGY_INTENT_AGENT_ID)
await agent_store.create(
{
"id": seed.STRATEGY_INTENT_AGENT_ID,
"name": "collision",
"user_id": "attacker",
}
)
with pytest.raises(HTTPException) as exc_info:
await strategy_agents.list_strategy_agents(request)
assert exc_info.value.status_code == 409
assert "owned by a user" in str(exc_info.value.detail)
@pytest.mark.asyncio
async def test_sensitive_catalog_and_writes_are_admin_only(
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
) -> None:
request, _, _ = await _request(tmp_path, monkeypatch, role="user")
# The active catalog is intentionally readable by the workbench.
assert len((await strategy_agents.list_strategy_agents(request)).agents) == 9
with pytest.raises(HTTPException) as list_error:
await strategy_agents.list_strategy_agents(
request,
include_disabled=True,
include_config=True,
)
assert list_error.value.status_code == 403
with pytest.raises(HTTPException) as create_error:
await strategy_agents.create_strategy_angle(
strategy_agents.StrategyAngleCreateRequest(name="非法新增"),
request,
)
assert create_error.value.status_code == 403
@pytest.mark.asyncio
async def test_angle_crud_is_global_and_delete_is_soft(
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
) -> None:
request, agent_store, role_store = await _request(tmp_path, monkeypatch)
created = await strategy_agents.create_strategy_angle(
strategy_agents.StrategyAngleCreateRequest(
name="科技产业视角",
description="评估关键技术和产业链韧性",
soul="你是科技产业策略分析智能体。",
model="model-a",
skills=["public-skill", "published-custom"],
),
request,
)
assert created.category == "angle"
assert created.fixed is False
assert created.enabled is True
assert created.id.startswith(seed.STRATEGY_ANGLE_AGENT_PREFIX)
assert created.model == "model-a"
assert created.skills == ["public-skill", "published-custom"]
updated = await strategy_agents.update_strategy_agent(
created.id,
strategy_agents.StrategyAgentUpdateRequest(
name="科技与产业链视角",
enabled=False,
sort_order=123,
skills=["public-skill"],
),
request,
)
assert updated.name == "科技与产业链视角"
assert updated.enabled is False
assert updated.sort_order == 123
assert updated.skills == ["public-skill"]
deleted = await strategy_agents.disable_strategy_angle(created.id, request)
assert deleted.enabled is False
# Soft delete protects saved projects and permits an administrator to
# restore the angle without recreating its ID or files.
assert await agent_store.get_any(created.id) is not None
assert await role_store.get_role(created.id) is not None
restored = await strategy_agents.update_strategy_agent(
created.id,
strategy_agents.StrategyAgentUpdateRequest(enabled=True),
request,
)
assert restored.enabled is True
assert (tmp_path / "agents" / created.id / ".strategy-role.yaml").is_file()
@pytest.mark.asyncio
async def test_memory_mode_recovers_dynamic_angle_from_folder_sidecar(
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
) -> None:
request, _, _ = await _request(tmp_path, monkeypatch)
created = await strategy_agents.create_strategy_angle(
strategy_agents.StrategyAngleCreateRequest(
name="恢复测试角度",
sort_order=177,
),
request,
)
await strategy_agents.disable_strategy_angle(created.id, request)
request.app.state.agent_store = MemoryAgentStore()
request.app.state.strategy_agent_role_store = MemoryStrategyAgentRoleStore()
recovered = await strategy_agents.list_strategy_agents(
request,
include_disabled=True,
include_config=True,
)
item = next(entry for entry in recovered.agents if entry.id == created.id)
assert item.name == "恢复测试角度"
assert item.enabled is False
assert item.sort_order == 177
assert (await request.app.state.agent_store.get_any(created.id))["user_id"] is None
@pytest.mark.asyncio
async def test_memory_mode_sidecar_keeps_default_angle_disabled_after_restart(
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
) -> None:
request, _, _ = await _request(tmp_path, monkeypatch)
await strategy_agents.update_strategy_agent(
seed.STRATEGY_SECURITY_AGENT_ID,
strategy_agents.StrategyAgentUpdateRequest(enabled=False, sort_order=188),
request,
)
request.app.state.agent_store = MemoryAgentStore()
request.app.state.strategy_agent_role_store = MemoryStrategyAgentRoleStore()
with pytest.raises(HTTPException) as run_error:
await parallel_agents.run_parallel_agents_stream(
request,
{
"task_name": "restart gate",
"brief": "disabled default must stay disabled",
"agent_ids": [seed.STRATEGY_SECURITY_AGENT_ID],
},
)
assert run_error.value.status_code == 409
recovered = await strategy_agents.list_strategy_agents(
request,
include_disabled=True,
include_config=True,
)
item = next(entry for entry in recovered.agents if entry.id == seed.STRATEGY_SECURITY_AGENT_ID)
assert item.enabled is False
assert item.sort_order == 188
@pytest.mark.asyncio
async def test_cancelled_create_compensates_every_persistence_layer(
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
) -> None:
request, agent_store, role_store = await _request(tmp_path, monkeypatch)
generated_id = f"{seed.STRATEGY_ANGLE_AGENT_PREFIX}cancelled"
monkeypatch.setattr(
strategy_agents,
"uuid4",
lambda: SimpleNamespace(hex="cancelled"),
)
async def cancel_set_extras(*_args, **_kwargs):
raise asyncio.CancelledError
monkeypatch.setattr(agent_store, "set_extras", cancel_set_extras)
with pytest.raises(asyncio.CancelledError):
await strategy_agents.create_strategy_angle(
strategy_agents.StrategyAngleCreateRequest(name="cancelled create"),
request,
)
assert await agent_store.get_any(generated_id) is None
assert await role_store.get_role(generated_id) is None
assert not (tmp_path / "agents" / generated_id).exists()
@pytest.mark.asyncio
async def test_cross_process_file_lock_excludes_second_handle(
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
) -> None:
paths = Paths(tmp_path)
monkeypatch.setattr(strategy_agents, "get_paths", lambda: paths)
first = strategy_agents._open_cross_process_lock(seed.STRATEGY_INTENT_AGENT_ID)
second = strategy_agents._open_cross_process_lock(seed.STRATEGY_INTENT_AGENT_ID)
try:
assert strategy_agents._try_cross_process_lock(first) is True
assert strategy_agents._try_cross_process_lock(second) is False
strategy_agents._release_cross_process_lock(first)
first = None
assert strategy_agents._try_cross_process_lock(second) is True
finally:
if first is not None:
strategy_agents._release_cross_process_lock(first)
if not second.closed:
strategy_agents._release_cross_process_lock(second)
@pytest.mark.asyncio
async def test_update_failure_restores_files_cache_and_role(
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
) -> None:
request, agent_store, role_store = await _request(tmp_path, monkeypatch)
created = await strategy_agents.create_strategy_angle(
strategy_agents.StrategyAngleCreateRequest(
name="事务前名称",
model="model-a",
skills=["public-skill"],
sort_order=166,
),
request,
)
agent_dir = tmp_path / "agents" / created.id
before_files = {name: (agent_dir / name).read_text(encoding="utf-8") for name in ("config.yaml", "SOUL.md", ".strategy-role.yaml")}
real_update = role_store.update_role
failed = False
async def fail_once(agent_id: str, **kwargs):
nonlocal failed
if kwargs.get("sort_order") == 188 and not failed:
failed = True
raise RuntimeError("injected role-store failure")
return await real_update(agent_id, **kwargs)
monkeypatch.setattr(role_store, "update_role", fail_once)
with pytest.raises(RuntimeError, match="injected role-store failure"):
await strategy_agents.update_strategy_agent(
created.id,
strategy_agents.StrategyAgentUpdateRequest(
name="不应留下的名称",
soul="不应留下的 SOUL",
skills=[],
sort_order=188,
),
request,
)
record = await agent_store.get_any(created.id)
role = await role_store.get_role(created.id)
assert record is not None and record["name"] == "事务前名称"
assert role is not None and role["sort_order"] == 166
assert (await agent_store.get_extras_for([created.id]))[created.id]["skills"] == ["public-skill"]
assert {name: (agent_dir / name).read_text(encoding="utf-8") for name in ("config.yaml", "SOUL.md", ".strategy-role.yaml")} == before_files
@pytest.mark.asyncio
async def test_fixed_roles_cannot_be_disabled_or_deleted(
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
) -> None:
request, _, _ = await _request(tmp_path, monkeypatch)
with pytest.raises(HTTPException) as update_error:
await strategy_agents.update_strategy_agent(
seed.STRATEGY_INTENT_AGENT_ID,
strategy_agents.StrategyAgentUpdateRequest(enabled=False),
request,
)
assert update_error.value.status_code == 409
with pytest.raises(HTTPException) as delete_error:
await strategy_agents.disable_strategy_angle(
seed.STRATEGY_JUDGE_AGENT_ID,
request,
)
assert delete_error.value.status_code == 409
@pytest.mark.asyncio
async def test_model_and_global_skill_visibility_are_validated(
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
) -> None:
request, _, _ = await _request(tmp_path, monkeypatch)
with pytest.raises(HTTPException) as model_error:
await strategy_agents.create_strategy_angle(
strategy_agents.StrategyAngleCreateRequest(
name="未知模型",
model="not-configured",
),
request,
)
assert model_error.value.status_code == 422
with pytest.raises(HTTPException) as skill_error:
await strategy_agents.create_strategy_angle(
strategy_agents.StrategyAngleCreateRequest(
name="私有技能",
skills=["private-custom"],
),
request,
)
assert skill_error.value.status_code == 422
assert "globally available" in str(skill_error.value.detail)
defaulted = await strategy_agents.create_strategy_angle(
strategy_agents.StrategyAngleCreateRequest(
name="默认角色模板",
description="关注跨领域风险",
),
request,
)
assert defaulted.soul
assert "默认角色模板" in defaulted.soul
assert "不替代其他角度" in defaulted.soul
@pytest.mark.asyncio
async def test_disabled_strategy_agent_cannot_be_started_via_parallel_api(
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
) -> None:
request, _, role_store = await _request(tmp_path, monkeypatch)
await role_store.ensure_defaults(seed.default_strategy_agent_roles())
await role_store.update_role(seed.STRATEGY_SECURITY_AGENT_ID, enabled=False)
with pytest.raises(HTTPException) as exc_info:
await parallel_agents.run_parallel_agents_stream(
request,
{
"task_name": "测试",
"brief": "验证停用闸门",
"agent_ids": [seed.STRATEGY_SECURITY_AGENT_ID],
},
)
assert exc_info.value.status_code == 409
@pytest.mark.asyncio
async def test_parallel_api_rejects_user_owned_strategy_backing_agent(
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
) -> None:
request, agent_store, role_store = await _request(tmp_path, monkeypatch)
await role_store.ensure_defaults(seed.default_strategy_agent_roles())
await agent_store.delete_builtin(seed.STRATEGY_SECURITY_AGENT_ID)
await agent_store.create(
{
"id": seed.STRATEGY_SECURITY_AGENT_ID,
"name": "collision",
"user_id": "attacker",
}
)
with pytest.raises(HTTPException) as exc_info:
await parallel_agents.run_parallel_agents_stream(
request,
{
"task_name": "测试",
"brief": "验证归属闸门",
"agent_ids": [seed.STRATEGY_SECURITY_AGENT_ID],
},
)
assert exc_info.value.status_code == 409
assert "owned by a user" in str(exc_info.value.detail)
@pytest.mark.asyncio
async def test_memory_registry_repairs_corrupted_fixed_role_metadata() -> None:
store = MemoryStrategyAgentRoleStore()
await store.create_role(
{
"agent_id": seed.STRATEGY_INTENT_AGENT_ID,
"category": "angle",
"fixed": False,
"enabled": False,
"sort_order": 999,
}
)
await store.ensure_defaults(seed.default_strategy_agent_roles())
repaired = await store.get_role(seed.STRATEGY_INTENT_AGENT_ID)
assert repaired is not None
assert repaired["category"] == "intent"
assert repaired["fixed"] is True
assert repaired["enabled"] is True
assert repaired["sort_order"] == 0
@pytest.mark.asyncio
async def test_sql_registry_preserves_disabled_defaults_and_soft_records(
tmp_path: Path,
) -> None:
engine = create_async_engine(f"sqlite+aiosqlite:///{tmp_path / 'strategy-agent-roles.db'}")
async with engine.begin() as connection:
await connection.run_sync(StrategyAgentRoleRow.__table__.create)
store = StrategyAgentRoleRepository(async_sessionmaker(engine, expire_on_commit=False))
try:
defaults = seed.default_strategy_agent_roles()
assert await store.ensure_defaults(defaults) == 9
assert await store.ensure_defaults(defaults) == 0
await store.update_role(seed.STRATEGY_SECURITY_AGENT_ID, enabled=False)
# Re-seeding must never undo an administrator's soft delete.
assert await store.ensure_defaults(defaults) == 0
disabled = await store.get_role(seed.STRATEGY_SECURITY_AGENT_ID)
assert disabled is not None
assert disabled["enabled"] is False
# Canonical fixed-role invariants are repaired, unlike angle lifecycle
# state which intentionally remains administrator-controlled.
async with store._sf() as session:
row = await session.get(
StrategyAgentRoleRow,
seed.STRATEGY_INTENT_AGENT_ID,
)
row.category = "angle"
row.fixed = False
row.enabled = False
row.sort_order = 999
await session.commit()
assert await store.ensure_defaults(defaults) == 0
repaired = await store.get_role(seed.STRATEGY_INTENT_AGENT_ID)
assert repaired is not None
assert repaired["category"] == "intent"
assert repaired["fixed"] is True
assert repaired["enabled"] is True
assert repaired["sort_order"] == 0
dynamic = await store.create_role(
{
"agent_id": "strategy-selection-angle-sql-test",
"category": "angle",
"fixed": False,
"enabled": True,
"sort_order": 150,
}
)
assert dynamic["category"] == "angle"
assert await store.update_role(dynamic["agent_id"], enabled=False)
assert await store.delete_role(dynamic["agent_id"]) is True
assert await store.get_role(dynamic["agent_id"]) is None
finally:
await engine.dispose()
@@ -0,0 +1,81 @@
import asyncio
from datetime import UTC, datetime
from types import SimpleNamespace
import pytest
from fastapi import HTTPException
from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
from app.gateway.routers import parallel_agent_tasks
from deerflow.persistence.base import Base
from deerflow.persistence.parallel_agent_tasks import ParallelAgentTaskRepository
@pytest.mark.asyncio
async def test_parallel_task_repository_rejects_stale_revision(tmp_path) -> None:
engine = create_async_engine(f"sqlite+aiosqlite:///{tmp_path / 'strategy-project-cas.db'}")
async with engine.begin() as connection:
await connection.run_sync(Base.metadata.create_all)
store = ParallelAgentTaskRepository(async_sessionmaker(engine, expire_on_commit=False))
try:
original = await store.create_task(
"user-1",
{
"id": "strategy-selection-cas",
"title": "original",
"messages": [{"snapshot": "original"}],
},
)
await asyncio.sleep(0.002)
newer = await store.update_task(
"strategy-selection-cas",
"user-1",
title="newer",
messages=[{"snapshot": "newer"}],
expected_updated_at=original["updated_at"],
)
assert newer is not None
stale = await store.update_task(
"strategy-selection-cas",
"user-1",
title="stale",
messages=[{"snapshot": "stale"}],
expected_updated_at=original["updated_at"],
)
assert stale is None
final = await store.get_task("strategy-selection-cas", "user-1")
assert final is not None
assert final["title"] == "newer"
assert final["messages"] == [{"snapshot": "newer"}]
finally:
await engine.dispose()
@pytest.mark.asyncio
async def test_parallel_task_route_reports_revision_conflict() -> None:
class ConflictStore:
async def update_task(self, *_args, **_kwargs):
return None
async def get_task(self, *_args, **_kwargs):
return {"id": "strategy-selection-cas"}
request = SimpleNamespace(
state=SimpleNamespace(user=SimpleNamespace(id="user-1")),
app=SimpleNamespace(state=SimpleNamespace(parallel_agent_task_store=ConflictStore())),
)
body = parallel_agent_tasks.TaskUpdateRequest(
title="stale",
expected_updated_at=datetime.now(UTC),
)
with pytest.raises(HTTPException) as error:
await parallel_agent_tasks.update_task(
request,
"strategy-selection-cas",
body,
)
assert error.value.status_code == 409
assert "其他页面更新" in str(error.value.detail)
@@ -0,0 +1,72 @@
from types import SimpleNamespace
import pytest
from fastapi import HTTPException
from app.gateway.routers import system_settings as system_settings_router
from deerflow.config.system_settings import SystemSettings
def test_strategy_project_demo_is_hidden_by_default() -> None:
assert SystemSettings().strategy_projects.taiwan_strait_demo_enabled is False
@pytest.mark.asyncio
async def test_non_admin_cannot_update_strategy_project_settings(
monkeypatch: pytest.MonkeyPatch,
) -> None:
async def ordinary_user(_request):
return SimpleNamespace(system_role="user")
monkeypatch.setattr(
system_settings_router,
"get_optional_user_from_request",
ordinary_user,
)
with pytest.raises(HTTPException) as error:
await system_settings_router.update_strategy_project_settings(
system_settings_router.StrategyProjectSettingsUpdateRequest(
taiwan_strait_demo_enabled=True,
),
SimpleNamespace(),
)
assert error.value.status_code == 403
@pytest.mark.asyncio
async def test_admin_can_update_strategy_project_settings(
monkeypatch: pytest.MonkeyPatch,
) -> None:
current = SystemSettings()
saved: list[SystemSettings] = []
async def admin_user(_request):
return SimpleNamespace(system_role="admin")
monkeypatch.setattr(
system_settings_router,
"get_optional_user_from_request",
admin_user,
)
monkeypatch.setattr(
system_settings_router,
"load_system_settings",
lambda: current,
)
monkeypatch.setattr(
system_settings_router,
"save_system_settings",
lambda settings: saved.append(settings) or settings,
)
response = await system_settings_router.update_strategy_project_settings(
system_settings_router.StrategyProjectSettingsUpdateRequest(
taiwan_strait_demo_enabled=True,
),
SimpleNamespace(),
)
assert response.taiwan_strait_demo_enabled is True
assert saved[0].strategy_projects.taiwan_strait_demo_enabled is True
@@ -0,0 +1,276 @@
"""Regression tests for the strategy-selection built-in agent seed."""
from __future__ import annotations
from pathlib import Path
import pytest
import yaml
from fastapi import HTTPException
from app.gateway.routers import _strategy_selection_seed as seed
from app.gateway.routers import agents as agents_router
from deerflow.config.paths import Paths
from deerflow.persistence.skills.memory import MemorySkillStore
from deerflow.skills.types import Skill, SkillCategory
@pytest.fixture()
def tmp_paths(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Paths:
paths = Paths(tmp_path)
monkeypatch.setattr(seed, "get_paths", lambda: paths)
return paths
def _asset(agent_id: str, filename: str) -> Path:
return seed._ASSETS_DIR / agent_id / filename
def test_seed_assets_define_all_nine_functional_agents() -> None:
agent_ids = tuple(seed.required_agent_ids())
assert len(agent_ids) == 9
assert len(set(agent_ids)) == 9
assert agent_ids[0] == seed.STRATEGY_INTENT_AGENT_ID
assert agent_ids[-2:] == (
seed.STRATEGY_JUDGE_AGENT_ID,
seed.STRATEGY_SOLUTION_AGENT_ID,
)
assert len(seed.STRATEGY_ANGLE_AGENT_IDS) == 6
for agent_id in agent_ids:
config_path = _asset(agent_id, "config.yaml")
soul_path = _asset(agent_id, "SOUL.md")
assert config_path.is_file(), agent_id
assert soul_path.is_file(), agent_id
config = yaml.safe_load(config_path.read_text(encoding="utf-8"))
soul = soul_path.read_text(encoding="utf-8")
assert config["id"] == agent_id
assert config["name"].strip()
assert config["description"].strip()
assert "作战战术" in soul
assert "定向政治说服" in soul
assert "降级" in soul
def test_seed_assets_use_role_appropriate_existing_skills_and_tools() -> None:
intent = yaml.safe_load(
_asset(seed.STRATEGY_INTENT_AGENT_ID, "config.yaml").read_text(encoding="utf-8")
)
assert intent["skills"] == ["intent-clarification-policy"]
assert intent["tool_groups"] == []
for agent_id in seed.STRATEGY_ANGLE_AGENT_IDS:
config = yaml.safe_load(_asset(agent_id, "config.yaml").read_text(encoding="utf-8"))
assert config["skills"] == ["policy-knowledge"]
assert config["tool_groups"] == ["web", "file:read"]
judge = yaml.safe_load(
_asset(seed.STRATEGY_JUDGE_AGENT_ID, "config.yaml").read_text(encoding="utf-8")
)
solution = yaml.safe_load(
_asset(seed.STRATEGY_SOLUTION_AGENT_ID, "config.yaml").read_text(encoding="utf-8")
)
assert judge["skills"] == []
assert judge["tool_groups"] == []
assert solution["skills"] == []
assert solution["tool_groups"] == ["file:write"]
def test_default_strategy_skills_are_enabled_in_the_system_catalog() -> None:
extensions_path = Path(__file__).resolve().parents[1] / "extensions_config.json"
extensions = yaml.safe_load(extensions_path.read_text(encoding="utf-8")) or {}
configured = extensions.get("skills") or {}
# A missing entry means enabled by default. An explicit false would make
# the seeded allowlist impossible to save under the server-side validator
# and silently remove the skill from strategy runs.
for skill_name in ("intent-clarification-policy", "policy-knowledge"):
assert (configured.get(skill_name) or {}).get("enabled", True) is True
def test_seed_assets_define_machine_readable_handoff_contracts() -> None:
intent_soul = _asset(seed.STRATEGY_INTENT_AGENT_ID, "SOUL.md").read_text(encoding="utf-8")
judge_soul = _asset(seed.STRATEGY_JUDGE_AGENT_ID, "SOUL.md").read_text(encoding="utf-8")
solution_soul = _asset(seed.STRATEGY_SOLUTION_AGENT_ID, "SOUL.md").read_text(encoding="utf-8")
assert "[INTENT_READY]" in intent_soul
for field in (
"name",
"detail",
"objective",
"prerequisites",
"constraints",
"deliverables",
"acceptanceCriteria",
"horizon",
"selectedAngleIds",
):
assert f'"{field}"' in intent_soul
assert "[JUDGEMENT_READY]" in judge_soul
for field in ("agentId", "score", "conclusion", "comment", "strengths", "risks"):
assert f'"{field}"' in judge_soul
assert '"recommendedAgentIds"' in judge_soul
assert "/mnt/user-data/outputs/综合策略方案.md" in solution_soul
def test_seed_creates_once_and_never_overwrites_admin_changes(tmp_paths: Paths) -> None:
expected = set(seed.required_agent_ids())
assert set(seed.ensure_strategy_selection_agents()) == expected
for agent_id in expected:
agent_dir = tmp_paths.agent_dir(agent_id)
assert (agent_dir / "config.yaml").is_file()
assert (agent_dir / "SOUL.md").is_file()
customized_agent = seed.STRATEGY_SECURITY_AGENT_ID
customized_soul = tmp_paths.agent_dir(customized_agent) / "SOUL.md"
customized_soul.write_text("管理员现场修改", encoding="utf-8")
assert seed.ensure_strategy_selection_agents() == []
assert customized_soul.read_text(encoding="utf-8") == "管理员现场修改"
def test_seed_upgrades_only_an_exact_known_legacy_default(
tmp_paths: Paths,
monkeypatch: pytest.MonkeyPatch,
) -> None:
assert seed.ensure_strategy_selection_agents()
intent_soul = tmp_paths.agent_dir(seed.STRATEGY_INTENT_AGENT_ID) / "SOUL.md"
legacy_content = b"legacy bundled intent soul\r\n"
intent_soul.write_bytes(legacy_content)
monkeypatch.setitem(
seed._LEGACY_DEFAULT_SOUL_HASHES,
seed.STRATEGY_INTENT_AGENT_ID,
seed._normalized_text_hash(legacy_content),
)
assert seed.ensure_strategy_selection_agents() == []
assert (
intent_soul.read_bytes()
== _asset(
seed.STRATEGY_INTENT_AGENT_ID,
"SOUL.md",
).read_bytes()
)
intent_soul.write_text("管理员现场修改", encoding="utf-8")
assert seed.ensure_strategy_selection_agents() == []
assert intent_soul.read_text(encoding="utf-8") == "管理员现场修改"
class _SkillStorage:
def __init__(self, skills: list[Skill]) -> None:
self._skills = skills
def load_skills(self, *, enabled_only: bool) -> list[Skill]:
if enabled_only:
return [skill for skill in self._skills if skill.enabled]
return list(self._skills)
def _skill(name: str, *, category: SkillCategory, enabled: bool = True) -> Skill:
directory = Path("skills") / category.value / name
return Skill(
name=name,
description=name,
license=None,
skill_dir=directory,
skill_file=directory / "SKILL.md",
relative_path=Path(name),
category=category,
enabled=enabled,
)
@pytest.mark.asyncio
async def test_strategy_skill_validation_accepts_only_global_catalog_names(
monkeypatch: pytest.MonkeyPatch,
) -> None:
skill_store = MemorySkillStore()
await skill_store.create(
{
"name": "published-custom",
"owner_user_id": "publisher",
"published": True,
}
)
storage = _SkillStorage(
[
_skill("public-skill", category=SkillCategory.PUBLIC),
_skill("published-custom", category=SkillCategory.CUSTOM),
]
)
monkeypatch.setattr(agents_router, "get_or_new_skill_storage", lambda **_: storage)
monkeypatch.setattr(
agents_router,
"get_skill_usage_entries",
lambda: {},
)
result = await agents_router._validate_strategy_agent_skills(
[" public-skill ", "published-custom", "public-skill"],
app_config=object(), # type: ignore[arg-type]
skill_store=skill_store,
)
assert result == ["public-skill", "published-custom"]
@pytest.mark.asyncio
@pytest.mark.parametrize(
("requested", "detail_fragment"),
[
("missing", "Unknown strategy agent skills"),
("disabled", "Disabled or archived strategy agent skills"),
("stale", "Disabled or archived strategy agent skills"),
("private-custom", "must be globally available"),
("orphan-custom", "must be globally available"),
],
)
async def test_strategy_skill_validation_rejects_unselectable_names(
monkeypatch: pytest.MonkeyPatch,
requested: str,
detail_fragment: str,
) -> None:
skill_store = MemorySkillStore()
await skill_store.create(
{
"name": "private-custom",
"owner_user_id": "owner",
"published": False,
}
)
storage = _SkillStorage(
[
_skill("disabled", category=SkillCategory.PUBLIC, enabled=False),
_skill("stale", category=SkillCategory.PUBLIC),
_skill("private-custom", category=SkillCategory.CUSTOM),
_skill("orphan-custom", category=SkillCategory.CUSTOM),
]
)
monkeypatch.setattr(agents_router, "get_or_new_skill_storage", lambda **_: storage)
monkeypatch.setattr(
agents_router,
"get_skill_usage_entries",
lambda: {"stale": {"state": "stale"}},
)
with pytest.raises(HTTPException) as exc_info:
await agents_router._validate_strategy_agent_skills(
[requested],
app_config=object(), # type: ignore[arg-type]
skill_store=skill_store,
)
assert exc_info.value.status_code == 422
assert detail_fragment in str(exc_info.value.detail)
def test_fixed_strategy_role_agents_cannot_be_deleted() -> None:
for agent_id in seed.required_agent_ids():
with pytest.raises(HTTPException) as exc_info:
agents_router._ensure_strategy_agent_deletable(agent_id)
assert exc_info.value.status_code == 409
agents_router._ensure_strategy_agent_deletable("ordinary-custom-agent")
@@ -1,8 +1,10 @@
"""Regression coverage for provider-safe transient context compression."""
from langchain.agents.middleware.types import ModelRequest, ModelResponse
from langchain_core.language_models.fake_chat_models import FakeListChatModel
from langchain_core.messages import AIMessage, HumanMessage, SystemMessage, ToolMessage
from deerflow.agents.middlewares.summarization_middleware import _ensure_latest_human_message
from deerflow.agents.middlewares.summarization_middleware import DeerFlowSummarizationMiddleware, _ensure_latest_human_message
def test_compression_restores_latest_human_turn_when_only_tool_tail_remains():
@@ -28,3 +30,37 @@ def test_compression_does_not_duplicate_human_turn_already_in_tail():
result = _ensure_latest_human_message([user], compressed)
assert result == compressed
def test_compression_uses_single_model_request_system_slot_for_generic_adapters():
model = FakeListChatModel(responses=["condensed history"])
middleware = DeerFlowSummarizationMiddleware(
model,
trigger=("messages", 3),
keep=("messages", 1),
)
request = ModelRequest(
model=model,
system_message=SystemMessage(content="agent prompt"),
messages=[
HumanMessage(content="first question", id="human-1"),
AIMessage(content="first answer", id="ai-1"),
HumanMessage(content="continue", id="human-2"),
],
)
captured: list[ModelRequest] = []
def handler(model_request: ModelRequest) -> ModelResponse:
captured.append(model_request)
return ModelResponse(result=[AIMessage(content="ok")])
middleware.wrap_model_call(request, handler)
assert len(captured) == 1
normalized = captured[0]
assert normalized.system_message is not None
assert "agent prompt" in normalized.system_message.text
assert "condensed history" in normalized.system_message.text
assert all(not isinstance(message, SystemMessage) for message in normalized.messages)
assert [message.type for message in normalized.messages] == ["human"]
assert normalized.messages[0].content == "continue"
@@ -375,8 +375,10 @@ async def test_admin_can_upload_and_activate_offline_encoder(monkeypatch, tmp_pa
class Embedding:
def __init__(self):
self.model_path = ""
self.reset_calls = 0
async def reset_local_encoder(self, *, model_path=None):
self.reset_calls += 1
if model_path is not None:
self.model_path = model_path
@@ -395,6 +397,17 @@ async def test_admin_can_upload_and_activate_offline_encoder(monkeypatch, tmp_pa
monkeypatch.setattr(llmwiki_index, "load_system_settings", SystemSettings)
monkeypatch.setattr(llmwiki_index, "save_system_settings", lambda value: saved.append(value) or value)
embedding = Embedding()
async def rebuild(_app, *, force=False):
assert force is True
embedding.model_path = saved[-1].local_wiki_encoder.model_path
monkeypatch.setattr(llmwiki_index, "rebuild_local_wiki_index_runtime", rebuild)
monkeypatch.setattr(
llmwiki_index,
"local_encoder_runtime_status",
lambda _app: embedding.local_encoder_status(),
)
app = FastAPI()
app.state.config = SimpleNamespace(
llmwiki=SimpleNamespace(
@@ -414,11 +427,15 @@ async def test_admin_can_upload_and_activate_offline_encoder(monkeypatch, tmp_pa
paths=["onnx/model.onnx", "config.json"],
)
active = tmp_path / "models" / "bge-m3"
revision = saved[-1].local_wiki_encoder.model_revision
active = tmp_path / "models" / "bge-m3-revisions" / revision
assert (active / "onnx" / "model.onnx").read_bytes() == b"onnx"
assert result["uploaded_files"] == 2
assert saved[-1].local_wiki_encoder.model_path == str(active.resolve())
assert saved[-1].local_wiki_encoder.mode == "local"
assert revision
assert embedding.model_path == str(active.resolve())
assert embedding.reset_calls == 0
def test_encoder_upload_rejects_parent_traversal():