Merge remote-tracking branch 'origin/master' into ji

# Conflicts:
#	.gitignore
#	frontend-web/src/components/workspace/artifacts/context.tsx
#	frontend-web/src/components/workspace/messages/message-group.tsx
#	offline-backend-20260512/backend/CLAUDE.md
#	offline-backend-20260512/backend/README.md
#	offline-backend-20260512/backend/app/gateway/app.py
#	offline-backend-20260512/backend/app/gateway/deps.py
#	offline-backend-20260512/backend/app/gateway/routers/llmwiki.py
This commit is contained in:
吉鑫升 committed 2026-08-24 14:21:19 +08:00
commit e818c24769
262 files changed
+29527 -5236

No files matched your search

@@ -26,7 +26,7 @@ from deerflow.persistence.tags.memory import MemoryTagStore
from deerflow.services.position_sync import PositionSyncService
@pytest.fixture
@pytest.fixture
def isolated_paths(tmp_path, monkeypatch):
"""Redirect get_paths() at a fresh temp directory for the duration of one test."""
monkeypatch.setenv("DEER_FLOW_HOME", str(tmp_path))
@@ -119,20 +119,20 @@ async def _default_positions() -> MemoryPositionStore:
}
)
return positions
@pytest.mark.asyncio
@pytest.mark.asyncio
async def test_agent_store_allows_duplicate_chinese_names_and_filters_visibility() -> None:
store = MemoryAgentStore()
chinese_name = "\u4e2d\u6587\u52a9\u624b"
await store.ensure_builtin({"id": "builtin-agent", "name": chinese_name, "description": "built in"})
await store.create({"id": "private-a", "name": chinese_name, "description": "private", "user_id": "user-a"})
await store.create({"id": "published-b", "name": chinese_name, "description": "published", "user_id": "user-b", "published": True})
user_a_ids = {agent["id"] for agent in await store.list_visible("user-a")}
assert user_a_ids == {"builtin-agent", "private-a", "published-b"}
await store.ensure_builtin({"id": "builtin-agent", "name": chinese_name, "description": "built in"})
await store.create({"id": "private-a", "name": chinese_name, "description": "private", "user_id": "user-a"})
await store.create({"id": "published-b", "name": chinese_name, "description": "published", "user_id": "user-b", "published": True})
user_a_ids = {agent["id"] for agent in await store.list_visible("user-a")}
assert user_a_ids == {"builtin-agent", "private-a", "published-b"}
user_c_ids = {agent["id"] for agent in await store.list_visible("user-c")}
assert user_c_ids == {"builtin-agent", "published-b"}
@@ -271,254 +271,270 @@ async def test_manual_favorite_upgrades_existing_auto_builtin_favorite(sql_sessi
async def test_agent_store_only_owner_can_update_or_delete() -> None:
store = MemoryAgentStore()
await store.ensure_builtin({"id": "builtin-agent", "name": "Built in"})
await store.create({"id": "private-a", "name": "Owned", "user_id": "user-a"})
assert await store.update("builtin-agent", "user-a", {"name": "Nope"}) is None
assert await store.update("private-a", "user-b", {"name": "Nope"}) is None
updated = await store.update("private-a", "user-a", {"name": "Renamed"})
assert updated is not None
assert updated["name"] == "Renamed"
assert await store.delete("private-a", "user-b") is False
assert await store.delete("private-a", "user-a") is True
@pytest.mark.asyncio
async def test_delete_builtin_only_targets_builtins() -> None:
store = MemoryAgentStore()
await store.ensure_builtin({"id": "builtin-agent", "name": "Built in"})
await store.create({"id": "owned-agent", "name": "Owned", "user_id": "user-a"})
# delete_builtin refuses to touch a user-owned agent
assert await store.delete_builtin("owned-agent") is False
assert await store.get_any("owned-agent") is not None
# delete_builtin succeeds on a built-in
assert await store.delete_builtin("builtin-agent") is True
assert await store.get_any("builtin-agent") is None
# And no-ops on a missing id
assert await store.delete_builtin("does-not-exist") is False
@pytest.mark.asyncio
async def test_update_builtin_only_targets_builtins() -> None:
store = MemoryAgentStore()
await store.ensure_builtin({"id": "builtin-agent", "name": "Built in"})
await store.create({"id": "owned-agent", "name": "Owned", "user_id": "user-a"})
# update_builtin succeeds on a built-in agent
updated = await store.update_builtin("builtin-agent", {"name": "Renamed by admin"})
assert updated is not None
assert updated["name"] == "Renamed by admin"
# update_builtin refuses to touch a user-owned agent (returns None)
assert await store.update_builtin("owned-agent", {"name": "Hijacked"}) is None
# And on a missing agent
assert await store.update_builtin("does-not-exist", {"name": "Ghost"}) is None
@pytest.mark.asyncio
async def test_get_editable_or_raise_admin_can_edit_builtin() -> None:
"""Route helper: admin gets edit access to any agent; non-admin still 403."""
from fastapi import HTTPException
from app.gateway.routers.agents import _get_editable_or_raise
store = MemoryAgentStore()
await store.ensure_builtin({"id": "builtin-agent", "name": "Built in"})
await store.create({"id": "owned-agent", "name": "Owned", "user_id": "user-a"})
# Owner edits their own agent → returns ('owner', record)
record, mode = await _get_editable_or_raise(
store, "owned-agent", "user-a", is_admin=False
)
assert mode == "owner" and record["id"] == "owned-agent"
# Admin edits a built-in agent → returns ('admin', record)
record, mode = await _get_editable_or_raise(
store, "builtin-agent", "user-a", is_admin=True
)
assert mode == "admin" and record["id"] == "builtin-agent"
# Non-admin tries to edit a built-in → 403
with pytest.raises(HTTPException) as exc:
await _get_editable_or_raise(store, "builtin-agent", "user-a", is_admin=False)
assert exc.value.status_code == 403
# Admin edits someone else's custom agent → returns ('admin', record).
# Behavior changed: admins manage the full agent catalog (built-in + any
# user's agents), not just built-ins. Non-admins are still owner-only.
await store.create(
{"id": "published-other", "name": "Pub", "user_id": "user-x", "published": True}
)
record, mode = await _get_editable_or_raise(
store, "published-other", "user-a", is_admin=True
)
assert mode == "admin" and record["id"] == "published-other"
def test_build_run_config_injects_custom_assistant_as_agent_id() -> None:
config = build_run_config("thread-1", None, None, assistant_id="agent-123")
assert config["configurable"]["thread_id"] == "thread-1"
assert config["configurable"]["agent_id"] == "agent-123"
assert "agent_name" not in config["configurable"]
def test_write_agent_config_persists_skills_into_config_yaml(isolated_paths) -> None:
agent_id = "agent-001"
_write_agent_config(
agent_id,
name="中文助手",
description="desc",
skills=["s1", "s2"],
model="gpt-x",
tool_groups=["tg-a"],
)
config_file = paths_module.get_paths().agent_dir(agent_id) / "config.yaml"
raw = yaml.safe_load(config_file.read_text(encoding="utf-8"))
assert raw["id"] == agent_id
assert raw["name"] == "中文助手"
assert raw["description"] == "desc"
assert raw["skills"] == ["s1", "s2"]
assert raw["model"] == "gpt-x"
assert raw["tool_groups"] == ["tg-a"]
def test_load_config_extras_returns_values_written_to_yaml(isolated_paths) -> None:
agent_id = "agent-002"
_write_agent_config(
agent_id,
name="agent-002",
description="",
skills=["s1"],
model=None,
tool_groups=None,
)
extras = _load_config_extras(agent_id)
assert extras == {"skills": ["s1"], "model": None, "tool_groups": None, "common_questions": None, "template_name": None, "seat_skill_directive": None}
def test_load_config_extras_missing_directory_returns_none_triple(isolated_paths) -> None:
extras = _load_config_extras("does-not-exist")
assert extras == {"skills": None, "model": None, "tool_groups": None, "common_questions": None, "template_name": None, "seat_skill_directive": None}
def test_write_agent_config_persists_common_questions(isolated_paths) -> None:
agent_id = "agent-cq-1"
# Structured {title, prompt} questions round-trip as clean dict mappings.
questions = [
{"title": "能做什么", "prompt": "这个智能体能做什么?"},
{"title": "上传文件", "prompt": "如何上传文件?"},
]
_write_agent_config(agent_id, name="助手", description="", common_questions=questions)
config_file = paths_module.get_paths().agent_dir(agent_id) / "config.yaml"
raw = yaml.safe_load(config_file.read_text(encoding="utf-8"))
assert raw["common_questions"] == questions
extras = _load_config_extras(agent_id)
assert [q.model_dump() for q in extras["common_questions"]] == questions
def test_write_agent_config_coerces_legacy_string_questions(isolated_paths) -> None:
"""Legacy ``list[str]`` configs coerce to {title, prompt} with title=content."""
agent_id = "agent-cq-legacy"
_write_agent_config(
agent_id, name="助手", description="", common_questions=["如何上传文件?"]
)
config_file = paths_module.get_paths().agent_dir(agent_id) / "config.yaml"
raw = yaml.safe_load(config_file.read_text(encoding="utf-8"))
assert raw["common_questions"] == [
{"title": "如何上传文件?", "prompt": "如何上传文件?"}
]
def test_write_agent_config_omits_common_questions_when_none(isolated_paths) -> None:
agent_id = "agent-cq-2"
_write_agent_config(agent_id, name="x", description="")
config_file = paths_module.get_paths().agent_dir(agent_id) / "config.yaml"
raw = yaml.safe_load(config_file.read_text(encoding="utf-8"))
assert "common_questions" not in raw
assert _load_config_extras(agent_id)["common_questions"] is None
def test_write_agent_config_explicit_empty_common_questions_is_persisted(isolated_paths) -> None:
agent_id = "agent-cq-3"
_write_agent_config(agent_id, name="x", description="", common_questions=[])
assert _load_config_extras(agent_id)["common_questions"] == []
def test_write_agent_config_explicit_empty_skills_is_persisted(isolated_paths) -> None:
agent_id = "agent-003"
_write_agent_config(agent_id, name="x", description="", skills=[])
extras = _load_config_extras(agent_id)
assert extras["skills"] == []
def test_write_agent_config_omits_skills_when_none(isolated_paths) -> None:
agent_id = "agent-004"
_write_agent_config(agent_id, name="x", description="")
config_file = paths_module.get_paths().agent_dir(agent_id) / "config.yaml"
raw = yaml.safe_load(config_file.read_text(encoding="utf-8"))
assert "skills" not in raw
assert "model" not in raw
assert "tool_groups" not in raw
@pytest.mark.asyncio
async def test_backfill_listing_cache_mirrors_config_values() -> None:
store = MemoryAgentStore()
cfg = AgentConfig(id="a1", name="Agent", skills=["s1", "s2"], tool_groups=["g1"], model="m1")
await _backfill_listing_cache(store, [("a1", cfg)])
extras = await store.get_extras_for(["a1"])
assert extras["a1"]["skills"] == ["s1", "s2"]
assert extras["a1"]["tool_groups"] == ["g1"]
assert extras["a1"]["model"] == "m1"
@pytest.mark.asyncio
async def test_backfill_listing_cache_is_idempotent_and_skips_unchanged(monkeypatch) -> None:
store = MemoryAgentStore()
cfg = AgentConfig(id="a1", name="Agent", skills=["s1"], tool_groups=None, model=None)
await _backfill_listing_cache(store, [("a1", cfg)])
# On a second run with identical config, no re-write should occur.
calls = {"replace": 0, "set": 0}
orig_replace = store.replace_skills
orig_set = store.set_extras
async def _replace(agent_id, skills):
calls["replace"] += 1
await orig_replace(agent_id, skills)
async def _set(agent_id, *, tool_groups, model):
calls["set"] += 1
await orig_set(agent_id, tool_groups=tool_groups, model=model)
monkeypatch.setattr(store, "replace_skills", _replace)
monkeypatch.setattr(store, "set_extras", _set)
await _backfill_listing_cache(store, [("a1", cfg)])
assert calls == {"replace": 0, "set": 0}
# Changing the config triggers a re-write.
cfg2 = AgentConfig(id="a1", name="Agent", skills=["s1", "s2"], tool_groups=None, model=None)
await _backfill_listing_cache(store, [("a1", cfg2)])
assert calls["replace"] == 1
await store.ensure_builtin({"id": "builtin-agent", "name": "Built in"})
await store.create({"id": "private-a", "name": "Owned", "user_id": "user-a"})
assert await store.update("builtin-agent", "user-a", {"name": "Nope"}) is None
assert await store.update("private-a", "user-b", {"name": "Nope"}) is None
updated = await store.update("private-a", "user-a", {"name": "Renamed"})
assert updated is not None
assert updated["name"] == "Renamed"
assert await store.delete("private-a", "user-b") is False
assert await store.delete("private-a", "user-a") is True
@pytest.mark.asyncio
async def test_delete_builtin_only_targets_builtins() -> None:
store = MemoryAgentStore()
await store.ensure_builtin({"id": "builtin-agent", "name": "Built in"})
await store.create({"id": "owned-agent", "name": "Owned", "user_id": "user-a"})
# delete_builtin refuses to touch a user-owned agent
assert await store.delete_builtin("owned-agent") is False
assert await store.get_any("owned-agent") is not None
# delete_builtin succeeds on a built-in
assert await store.delete_builtin("builtin-agent") is True
assert await store.get_any("builtin-agent") is None
# And no-ops on a missing id
assert await store.delete_builtin("does-not-exist") is False
@pytest.mark.asyncio
async def test_update_builtin_only_targets_builtins() -> None:
store = MemoryAgentStore()
await store.ensure_builtin({"id": "builtin-agent", "name": "Built in"})
await store.create({"id": "owned-agent", "name": "Owned", "user_id": "user-a"})
# update_builtin succeeds on a built-in agent
updated = await store.update_builtin("builtin-agent", {"name": "Renamed by admin"})
assert updated is not None
assert updated["name"] == "Renamed by admin"
# update_builtin refuses to touch a user-owned agent (returns None)
assert await store.update_builtin("owned-agent", {"name": "Hijacked"}) is None
# And on a missing agent
assert await store.update_builtin("does-not-exist", {"name": "Ghost"}) is None
@pytest.mark.asyncio
async def test_get_editable_or_raise_admin_can_edit_builtin() -> None:
"""Route helper: admin gets edit access to any agent; non-admin still 403."""
from fastapi import HTTPException
from app.gateway.routers.agents import _get_editable_or_raise
store = MemoryAgentStore()
await store.ensure_builtin({"id": "builtin-agent", "name": "Built in"})
await store.create({"id": "owned-agent", "name": "Owned", "user_id": "user-a"})
# Owner edits their own agent → returns ('owner', record)
record, mode = await _get_editable_or_raise(
store, "owned-agent", "user-a", is_admin=False
)
assert mode == "owner" and record["id"] == "owned-agent"
# Admin edits a built-in agent → returns ('admin', record)
record, mode = await _get_editable_or_raise(
store, "builtin-agent", "user-a", is_admin=True
)
assert mode == "admin" and record["id"] == "builtin-agent"
# Non-admin tries to edit a built-in → 403
with pytest.raises(HTTPException) as exc:
await _get_editable_or_raise(store, "builtin-agent", "user-a", is_admin=False)
assert exc.value.status_code == 403
# Admin edits someone else's custom agent → returns ('admin', record).
# Behavior changed: admins manage the full agent catalog (built-in + any
# user's agents), not just built-ins. Non-admins are still owner-only.
await store.create(
{"id": "published-other", "name": "Pub", "user_id": "user-x", "published": True}
)
record, mode = await _get_editable_or_raise(
store, "published-other", "user-a", is_admin=True
)
assert mode == "admin" and record["id"] == "published-other"
def test_build_run_config_injects_custom_assistant_as_agent_id() -> None:
config = build_run_config("thread-1", None, None, assistant_id="agent-123")
assert config["configurable"]["thread_id"] == "thread-1"
assert config["configurable"]["agent_id"] == "agent-123"
assert "agent_name" not in config["configurable"]
def test_write_agent_config_persists_skills_into_config_yaml(isolated_paths) -> None:
agent_id = "agent-001"
_write_agent_config(
agent_id,
name="中文助手",
description="desc",
skills=["s1", "s2"],
model="gpt-x",
tool_groups=["tg-a"],
)
config_file = paths_module.get_paths().agent_dir(agent_id) / "config.yaml"
raw = yaml.safe_load(config_file.read_text(encoding="utf-8"))
assert raw["id"] == agent_id
assert raw["name"] == "中文助手"
assert raw["description"] == "desc"
assert raw["skills"] == ["s1", "s2"]
assert raw["model"] == "gpt-x"
assert raw["tool_groups"] == ["tg-a"]
def test_load_config_extras_returns_values_written_to_yaml(isolated_paths) -> None:
agent_id = "agent-002"
_write_agent_config(
agent_id,
name="agent-002",
description="",
skills=["s1"],
model=None,
tool_groups=None,
)
extras = _load_config_extras(agent_id)
assert extras == {
"skills": ["s1"],
"model": None,
"tool_groups": None,
"common_questions": None,
"template_name": None,
"seat_skill_directive": None,
"llmwiki_knowledge_base_ids": None,
}
def test_load_config_extras_missing_directory_returns_none_triple(isolated_paths) -> None:
extras = _load_config_extras("does-not-exist")
assert extras == {
"skills": None,
"model": None,
"tool_groups": None,
"common_questions": None,
"template_name": None,
"seat_skill_directive": None,
"llmwiki_knowledge_base_ids": None,
}
def test_write_agent_config_persists_common_questions(isolated_paths) -> None:
agent_id = "agent-cq-1"
# Structured {title, prompt} questions round-trip as clean dict mappings.
questions = [
{"title": "能做什么", "prompt": "这个智能体能做什么?"},
{"title": "上传文件", "prompt": "如何上传文件?"},
]
_write_agent_config(agent_id, name="助手", description="", common_questions=questions)
config_file = paths_module.get_paths().agent_dir(agent_id) / "config.yaml"
raw = yaml.safe_load(config_file.read_text(encoding="utf-8"))
assert raw["common_questions"] == questions
extras = _load_config_extras(agent_id)
assert [q.model_dump() for q in extras["common_questions"]] == questions
def test_write_agent_config_coerces_legacy_string_questions(isolated_paths) -> None:
"""Legacy ``list[str]`` configs coerce to {title, prompt} with title=content."""
agent_id = "agent-cq-legacy"
_write_agent_config(
agent_id, name="助手", description="", common_questions=["如何上传文件?"]
)
config_file = paths_module.get_paths().agent_dir(agent_id) / "config.yaml"
raw = yaml.safe_load(config_file.read_text(encoding="utf-8"))
assert raw["common_questions"] == [
{"title": "如何上传文件?", "prompt": "如何上传文件?"}
]
def test_write_agent_config_omits_common_questions_when_none(isolated_paths) -> None:
agent_id = "agent-cq-2"
_write_agent_config(agent_id, name="x", description="")
config_file = paths_module.get_paths().agent_dir(agent_id) / "config.yaml"
raw = yaml.safe_load(config_file.read_text(encoding="utf-8"))
assert "common_questions" not in raw
assert _load_config_extras(agent_id)["common_questions"] is None
def test_write_agent_config_explicit_empty_common_questions_is_persisted(isolated_paths) -> None:
agent_id = "agent-cq-3"
_write_agent_config(agent_id, name="x", description="", common_questions=[])
assert _load_config_extras(agent_id)["common_questions"] == []
def test_write_agent_config_explicit_empty_skills_is_persisted(isolated_paths) -> None:
agent_id = "agent-003"
_write_agent_config(agent_id, name="x", description="", skills=[])
extras = _load_config_extras(agent_id)
assert extras["skills"] == []
def test_write_agent_config_omits_skills_when_none(isolated_paths) -> None:
agent_id = "agent-004"
_write_agent_config(agent_id, name="x", description="")
config_file = paths_module.get_paths().agent_dir(agent_id) / "config.yaml"
raw = yaml.safe_load(config_file.read_text(encoding="utf-8"))
assert "skills" not in raw
assert "model" not in raw
assert "tool_groups" not in raw
@pytest.mark.asyncio
async def test_backfill_listing_cache_mirrors_config_values() -> None:
store = MemoryAgentStore()
cfg = AgentConfig(id="a1", name="Agent", skills=["s1", "s2"], tool_groups=["g1"], model="m1")
await _backfill_listing_cache(store, [("a1", cfg)])
extras = await store.get_extras_for(["a1"])
assert extras["a1"]["skills"] == ["s1", "s2"]
assert extras["a1"]["tool_groups"] == ["g1"]
assert extras["a1"]["model"] == "m1"
@pytest.mark.asyncio
async def test_backfill_listing_cache_is_idempotent_and_skips_unchanged(monkeypatch) -> None:
store = MemoryAgentStore()
cfg = AgentConfig(id="a1", name="Agent", skills=["s1"], tool_groups=None, model=None)
await _backfill_listing_cache(store, [("a1", cfg)])
# On a second run with identical config, no re-write should occur.
calls = {"replace": 0, "set": 0}
orig_replace = store.replace_skills
orig_set = store.set_extras
async def _replace(agent_id, skills):
calls["replace"] += 1
await orig_replace(agent_id, skills)
async def _set(agent_id, *, tool_groups, model):
calls["set"] += 1
await orig_set(agent_id, tool_groups=tool_groups, model=model)
monkeypatch.setattr(store, "replace_skills", _replace)
monkeypatch.setattr(store, "set_extras", _set)
await _backfill_listing_cache(store, [("a1", cfg)])
assert calls == {"replace": 0, "set": 0}
# Changing the config triggers a re-write.
cfg2 = AgentConfig(id="a1", name="Agent", skills=["s1", "s2"], tool_groups=None, model=None)
await _backfill_listing_cache(store, [("a1", cfg2)])
assert calls["replace"] == 1
@@ -38,17 +38,27 @@ class _ChainStore:
return self.chain
class _AgentStore:
def __init__(self, agents: dict[str, dict[str, object]] | None = None) -> None:
self.agents = agents or {}
async def get_any(self, agent_id: str) -> dict[str, object] | None:
return self.agents.get(agent_id)
def _request(
role: str,
chain: dict[str, object] | None = None,
*,
email: str = "lqq@example.com",
agents: dict[str, dict[str, object]] | None = None,
):
return SimpleNamespace(
app=SimpleNamespace(
state=SimpleNamespace(
business_mapping_store=_MappingStore(),
roundtable_chain_store=_ChainStore(chain),
agent_store=_AgentStore(agents),
)
),
state=SimpleNamespace(user=SimpleNamespace(id="admin-id", email=email, system_role=role)),
@@ -130,3 +140,34 @@ async def test_global_mapping_rejects_a_private_chain() -> None:
assert error.value.status_code == 400
assert request.app.state.business_mapping_store.calls == []
@pytest.mark.asyncio
async def test_global_mapping_rejects_a_chain_with_an_unpublished_agent_seat() -> None:
request = _request(
"admin",
{
"id": "chain-8bf",
"title": "岗位协同链",
"is_public": True,
"seats": [
{"agent_id": "published", "name": "已发布智能体"},
{"agent_id": "private", "name": "未发布智能体"},
],
},
agents={
"published": {"id": "published", "user_id": "owner", "published": True, "is_private": False},
"private": {"id": "private", "user_id": "owner", "published": False, "is_private": False},
},
)
with pytest.raises(HTTPException) as error:
await business_mapping_router.update_mapping(
request,
"8BF",
business_mapping_router.BusinessMappingUpdateRequest(chain_id="chain-8bf"),
)
assert error.value.status_code == 400
assert "未发布智能体" in error.value.detail
assert request.app.state.business_mapping_store.calls == []
@@ -0,0 +1,154 @@
"""Tests for compact/sidebar-summary menu overrides (简介模式菜单).
Overrides are stored per ``menu_type`` (A / B) so two website deployments can
keep independent left-nav layouts. Saving type B must not wipe type A.
"""
from __future__ import annotations
import pytest
import pytest_asyncio
from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
from deerflow.persistence.base import Base
from deerflow.persistence.compact_menu_overrides import (
MemoryCompactMenuOverrideStore,
CompactMenuOverrideRepository,
normalize_compact_menu_type,
)
from deerflow.persistence.compact_menu_overrides.keys import public_node_id, storage_node_id
@pytest_asyncio.fixture
async def store(tmp_path):
engine = create_async_engine(f"sqlite+aiosqlite:///{tmp_path / 'compact-menu.db'}")
async with engine.begin() as conn:
import deerflow.persistence.compact_menu_overrides.model # noqa: F401
await conn.run_sync(Base.metadata.create_all)
sf = async_sessionmaker(engine, expire_on_commit=False)
return CompactMenuOverrideRepository(sf)
def test_normalize_compact_menu_type():
assert normalize_compact_menu_type(None) == "A"
assert normalize_compact_menu_type("") == "A"
assert normalize_compact_menu_type("a") == "A"
assert normalize_compact_menu_type("default") == "A"
assert normalize_compact_menu_type("B") == "B"
assert normalize_compact_menu_type("alt") == "B"
assert normalize_compact_menu_type("2") == "B"
def test_storage_keys_keep_type_a_unprefixed():
assert storage_node_id("A", "workspace-chats") == "workspace-chats"
assert storage_node_id("B", "workspace-chats") == "B::workspace-chats"
assert public_node_id("B::workspace-chats", "B") == "workspace-chats"
assert public_node_id("workspace-chats", "A") == "workspace-chats"
@pytest.mark.asyncio
async def test_replace_all_roundtrips(store: CompactMenuOverrideRepository):
out = await store.replace_all(
[
{"node_id": "workspace-chats", "placement": "settings", "sort_order": 1, "label": "会话"},
{"node_id": "workspace-agents", "placement": "sidebar", "sort_order": 0, "label": None},
],
updated_by="admin-1",
)
assert len(out) == 2
rows = {r["node_id"]: r for r in await store.list_overrides()}
assert rows["workspace-chats"]["label"] == "会话"
assert rows["workspace-chats"]["placement"] == "settings"
assert rows["workspace-chats"]["menu_type"] == "A"
assert rows["workspace-agents"]["updated_by"] == "admin-1"
@pytest.mark.asyncio
async def test_replace_all_is_full_replacement_within_type(store: CompactMenuOverrideRepository):
await store.replace_all([{"node_id": "a"}, {"node_id": "b"}], menu_type="A")
await store.replace_all([{"node_id": "c"}], menu_type="A")
ids = {r["node_id"] for r in await store.list_overrides("A")}
assert ids == {"c"}
@pytest.mark.asyncio
async def test_types_are_isolated(store: CompactMenuOverrideRepository):
await store.replace_all(
[{"node_id": "workspace-chats", "placement": "sidebar", "sort_order": 0, "label": "对话A"}],
menu_type="A",
)
await store.replace_all(
[{"node_id": "workspace-chats", "placement": "settings", "sort_order": 2, "label": "对话B"}],
menu_type="B",
)
a_rows = await store.list_overrides("A")
b_rows = await store.list_overrides("B")
assert len(a_rows) == 1
assert a_rows[0]["node_id"] == "workspace-chats"
assert a_rows[0]["label"] == "对话A"
assert a_rows[0]["placement"] == "sidebar"
assert len(b_rows) == 1
assert b_rows[0]["node_id"] == "workspace-chats"
assert b_rows[0]["label"] == "对话B"
assert b_rows[0]["placement"] == "settings"
await store.replace_all([], menu_type="B")
assert await store.list_overrides("B") == []
leftover = await store.list_overrides("A")
assert len(leftover) == 1
assert leftover[0]["label"] == "对话A"
@pytest.mark.asyncio
async def test_omitted_menu_type_reads_legacy_rows():
"""Old pages that do not send menu_type still see the original compact menu."""
mem = MemoryCompactMenuOverrideStore()
mem._rows["workspace-chats"] = {
"node_id": "workspace-chats",
"placement": "settings",
"sort_order": 1,
"label": "旧对话",
}
rows = await mem.list_overrides(None)
assert len(rows) == 1
assert rows[0]["node_id"] == "workspace-chats"
assert rows[0]["label"] == "旧对话"
assert rows[0]["menu_type"] == "A"
assert await mem.list_overrides("B") == []
@pytest.mark.asyncio
async def test_sql_blank_menu_type_is_treated_as_original(store: CompactMenuOverrideRepository):
from sqlalchemy import update
from deerflow.persistence.compact_menu_overrides.model import CompactMenuOverrideRow
await store.replace_all(
[{"node_id": "legacy", "placement": "sidebar", "sort_order": 0, "label": "旧菜单"}],
)
async with store._sf() as session:
await session.execute(update(CompactMenuOverrideRow).values(menu_type=""))
await session.commit()
rows = await store.list_overrides(None)
assert {r["node_id"] for r in rows} == {"legacy"}
assert rows[0]["label"] == "旧菜单"
assert await store.list_overrides("B") == []
@pytest.mark.asyncio
async def test_memory_store_parity():
mem = MemoryCompactMenuOverrideStore()
await mem.replace_all(
[{"node_id": "x", "placement": "settings", "sort_order": 3}],
menu_type="B",
updated_by="u",
)
await mem.replace_all([{"node_id": "y", "sort_order": 0}], menu_type="A")
b_rows = await mem.list_overrides("B")
assert b_rows[0]["node_id"] == "x"
assert b_rows[0]["menu_type"] == "B"
assert b_rows[0]["placement"] == "settings"
a_ids = {r["node_id"] for r in await mem.list_overrides("A")}
assert a_ids == {"y"}
@@ -0,0 +1,83 @@
"""Fault-tolerance coverage for Deep Research progress events."""
import pytest
from deerflow.agents.deep_research.adapters.event_sink import PersistingEventSink
class _UnavailableEventRepository:
async def append(self, **kwargs): # noqa: ANN003
raise RuntimeError("database temporarily unavailable")
@pytest.mark.asyncio
async def test_event_persistence_failure_keeps_job_live_and_emits_unique_fallback_event():
published: list[dict] = []
async def publish(event: dict) -> None:
published.append(event)
sink = PersistingEventSink(
_UnavailableEventRepository(),
session_id="drs_1",
job_id="drj_1",
on_event=publish,
)
first = await sink.emit("phase_changed", phase="planning", payload={"to": "planning"})
second = await sink.emit("queries_planned", phase="collecting", payload={"queries": ["AI"]})
assert (first.seq, second.seq) == (-1, -2)
assert first.payload["eventPersistenceDegraded"] is True
assert published[0]["liveId"] == "event-persistence-fallback:drj_1:1"
assert published[1]["liveId"] == "event-persistence-fallback:drj_1:2"
@pytest.mark.asyncio
async def test_live_publish_failure_does_not_fail_event_delivery():
class _EventRepository:
async def append(self, **kwargs): # noqa: ANN003
return {
"seq": 1,
"event_type": kwargs["event_type"],
"phase": kwargs["phase"],
"payload": kwargs["payload"],
}
async def broken_publisher(event: dict) -> None: # noqa: ARG001
raise RuntimeError("browser disconnected")
sink = PersistingEventSink(
_EventRepository(),
session_id="drs_1",
job_id="drj_1",
on_event=broken_publisher,
)
event = await sink.emit("phase_changed", phase="planning")
assert event.seq == 1
@pytest.mark.asyncio
async def test_document_rewrite_milestone_is_a_supported_durable_event():
"""Guard the artifact-rewrite job path against EventType regressions."""
class _EventRepository:
async def append(self, **kwargs): # noqa: ANN003
return {
"seq": 1,
"event_type": kwargs["event_type"],
"phase": kwargs["phase"],
"payload": kwargs["payload"],
}
sink = PersistingEventSink(_EventRepository(), session_id="drs_1", job_id="drj_1")
event = await sink.emit(
"document_rewrite",
phase="planning",
payload={"type": "requirements_started"},
)
assert event.type == "document_rewrite"
@@ -0,0 +1,72 @@
"""Failure-ordering regression coverage for final Deep Research report writes."""
import pytest
from app.gateway import deep_research_job_executor as executor_module
from app.gateway.deep_research_job_executor import DeepResearchJobExecutor
from deerflow.agents.deep_research.events import DeepResearchEvent
from deerflow.agents.deep_research.types import DeepResearchResult
class _JobStore:
def __init__(self, session_store) -> None:
self._session_store = session_store
self.progress_calls: list[dict] = []
async def update_progress(self, job_id: str, **fields): # noqa: ARG002
assert self._session_store.report_updates, "report must be persisted before job completion"
self.progress_calls.append(fields)
return {"id": job_id, **fields}
class _SessionStore:
def __init__(self, *, available: bool = True) -> None:
self.available = available
self.report_updates: list[dict] = []
async def update(self, session_id: str, **fields): # noqa: ARG002
if not self.available:
raise RuntimeError("temporary session database failure")
self.report_updates.append(fields)
return {"id": session_id, **fields}
@pytest.mark.asyncio
async def test_report_is_persisted_before_job_is_marked_completed():
sessions = _SessionStore()
jobs = _JobStore(sessions)
runner = DeepResearchJobExecutor(jobs, sessions, event_store=None)
await runner._mark_completed(
"drj_1",
"drs_1",
"worker_1",
DeepResearchResult(report_markdown="# 报告", source_ids=["src_1"]),
)
assert sessions.report_updates[0]["report_markdown"] == "# 报告"
assert jobs.progress_calls[0]["status"] == "completed"
@pytest.mark.asyncio
async def test_report_projection_failure_never_marks_job_completed(monkeypatch):
monkeypatch.setattr(executor_module, "_REPORT_PROJECTION_RETRY_ATTEMPTS", 2)
monkeypatch.setattr(executor_module, "_REPORT_PROJECTION_RETRY_DELAY_SECONDS", 0)
sessions = _SessionStore(available=False)
jobs = _JobStore(sessions)
runner = DeepResearchJobExecutor(jobs, sessions, event_store=None)
with pytest.raises(RuntimeError, match="研究报告未能保存"):
await runner._mark_completed(
"drj_1",
"drs_1",
"worker_1",
DeepResearchResult(report_markdown="# 报告"),
)
assert jobs.progress_calls == []
def test_terminal_timeline_events_are_valid_durable_event_types():
assert DeepResearchEvent(type="job_completed", phase="done").type == "job_completed"
assert DeepResearchEvent(type="job_failed", phase="done").type == "job_failed"
@@ -0,0 +1,538 @@
"""Persistence tests for deep-research sessions, jobs, events, sources, messages.
Uses in-memory SQLite + aiosqlite, mirroring ``test_ai_writing_session_repo``.
Focuses on the durable-job mechanics that are load-bearing for correctness:
- Session CRUD + user isolation.
- Job ``try_create_or_get_active`` idempotency (unique dedupe key).
- Job lease claim / renew / release (atomic CAS).
- Two-phase cancel (``request_cancel`` → ``finalize_cancel``).
- Event seq monotonicity + ``list_after`` replay (SSE reconnect correctness).
Pattern: a plain ``async def _make_repos()`` helper (not a fixture) — matches
the project convention for async DB setup in pytest-asyncio strict mode.
"""
from __future__ import annotations
from datetime import UTC, datetime, timedelta
import pytest
from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
async def _make_repos():
"""Create an in-memory SQLite repo set with all deep-research tables."""
from deerflow.persistence.base import Base
from deerflow.persistence.deep_research_events.model import DeepResearchEventRow # noqa: F401
from deerflow.persistence.deep_research_events.sql import DeepResearchEventRepository
from deerflow.persistence.deep_research_jobs.model import DeepResearchJobRow # noqa: F401
from deerflow.persistence.deep_research_jobs.sql import DeepResearchJobRepository
from deerflow.persistence.deep_research_messages.model import DeepResearchMessageRow # noqa: F401
from deerflow.persistence.deep_research_messages.sql import DeepResearchMessageRepository
from deerflow.persistence.deep_research_sessions.model import DeepResearchSessionRow # noqa: F401
from deerflow.persistence.deep_research_sessions.sql import DeepResearchSessionRepository
from deerflow.persistence.deep_research_sources.model import DeepResearchSourceRow # noqa: F401
from deerflow.persistence.deep_research_sources.sql import DeepResearchSourceRepository
engine = create_async_engine("sqlite+aiosqlite:///:memory:")
async with engine.begin() as conn:
await conn.run_sync(Base.metadata.create_all)
sf = async_sessionmaker(engine, expire_on_commit=False)
return {
"sessions": DeepResearchSessionRepository(sf),
"jobs": DeepResearchJobRepository(sf),
"events": DeepResearchEventRepository(sf),
"sources": DeepResearchSourceRepository(sf),
"messages": DeepResearchMessageRepository(sf),
"_engine": engine,
}
# ── sessions ────────────────────────────────────────────────────────────────
@pytest.mark.asyncio
async def test_session_create_and_get():
repos = await _make_repos()
try:
created = await repos["sessions"].create(id="drs_1", user_id="u1", title="Test", query="AI research", mode="deep")
assert created["id"] == "drs_1"
assert created["status"] == "draft"
got = await repos["sessions"].get("drs_1", user_id="u1")
assert got is not None
assert got["query"] == "AI research"
finally:
await repos["_engine"].dispose()
@pytest.mark.asyncio
async def test_deep_research_writes_never_depend_on_post_commit_refresh(monkeypatch):
"""Control-plane writes must survive a MySQL replica-lag readback."""
from sqlalchemy.ext.asyncio import AsyncSession
async def fail_refresh(self, instance, *args, **kwargs): # noqa: ANN001, ARG001
raise AssertionError("Deep Research writes must not call session.refresh")
monkeypatch.setattr(AsyncSession, "refresh", fail_refresh)
repos = await _make_repos()
try:
session = await repos["sessions"].create(
id="drs_1", user_id="u1", title="Test", query="AI research"
)
assert session["id"] == "drs_1"
assert await repos["sessions"].update("drs_1", user_id="u1", status="running")
job, created = await repos["jobs"].try_create_or_get_active(
id="drj_1", session_id="drs_1", user_id="u1"
)
assert created is True
assert job["id"] == "drj_1"
source = await repos["sources"].upsert(
session_id="drs_1",
id="src_1",
user_id="u1",
title="A",
raw_content="source content",
source="web",
content_hash="hash_1",
)
assert source["id"] == "src_1"
message = await repos["messages"].append(
id="msg_1",
session_id="drs_1",
user_id="u1",
role="assistant",
content="已开始撰写",
)
assert message["id"] == "msg_1"
finally:
await repos["_engine"].dispose()
@pytest.mark.asyncio
async def test_session_user_isolation():
repos = await _make_repos()
try:
await repos["sessions"].create(id="drs_1", user_id="u1", query="q1")
assert await repos["sessions"].get("drs_1", user_id="u2") is None
finally:
await repos["_engine"].dispose()
@pytest.mark.asyncio
async def test_session_list_strips_heavy_columns():
repos = await _make_repos()
try:
await repos["sessions"].create(id="drs_1", user_id="u1", query="q", config_snapshot={"mode": "deep"})
items = await repos["sessions"].list_by_user(user_id="u1")
assert len(items) == 1
assert "report_markdown" not in items[0]
assert "config_snapshot" not in items[0]
finally:
await repos["_engine"].dispose()
@pytest.mark.asyncio
async def test_session_update_and_delete():
repos = await _make_repos()
try:
await repos["sessions"].create(id="drs_1", user_id="u1", query="q")
updated = await repos["sessions"].update("drs_1", user_id="u1", title="New Title")
assert updated["title"] == "New Title"
assert await repos["sessions"].delete("drs_1", user_id="u1") is True
assert await repos["sessions"].get("drs_1", user_id="u1") is None
finally:
await repos["_engine"].dispose()
@pytest.mark.asyncio
async def test_count_active_by_user():
repos = await _make_repos()
try:
await repos["sessions"].create(id="drs_1", user_id="u1", query="q", status="running")
await repos["sessions"].create(id="drs_2", user_id="u1", query="q", status="completed")
count = await repos["sessions"].count_active_by_user(user_id="u1")
assert count == 1
finally:
await repos["_engine"].dispose()
# ── jobs: idempotent create ─────────────────────────────────────────────────
@pytest.mark.asyncio
async def test_job_try_create_returns_created_true():
repos = await _make_repos()
try:
job, created = await repos["jobs"].try_create_or_get_active(id="drj_1", session_id="drs_1", user_id="u1", request_id="req_1")
assert created is True
assert job["status"] == "queued"
assert job["active_dedupe_key"] is not None
finally:
await repos["_engine"].dispose()
@pytest.mark.asyncio
async def test_job_create_never_reads_back_after_commit(monkeypatch):
"""A committed job must not fail when a MySQL replica briefly lags."""
from sqlalchemy.ext.asyncio import AsyncSession
async def fail_refresh(self, instance, *args, **kwargs): # noqa: ANN001, ARG001
raise AssertionError("DeepResearchJobRepository must not call session.refresh")
monkeypatch.setattr(AsyncSession, "refresh", fail_refresh)
repos = await _make_repos()
try:
job, created = await repos["jobs"].try_create_or_get_active(
id="drj_1",
session_id="drs_1",
user_id="u1",
request_id="req_1",
)
assert created is True
assert job["id"] == "drj_1"
assert job["status"] == "queued"
finally:
await repos["_engine"].dispose()
@pytest.mark.asyncio
async def test_job_try_create_idempotent_returns_existing():
repos = await _make_repos()
try:
job1, created1 = await repos["jobs"].try_create_or_get_active(id="drj_1", session_id="drs_1", user_id="u1", request_id="req_1")
job2, created2 = await repos["jobs"].try_create_or_get_active(id="drj_2", session_id="drs_1", user_id="u1", request_id="req_2")
assert created1 is True
assert created2 is False
assert job2["id"] == job1["id"]
finally:
await repos["_engine"].dispose()
@pytest.mark.asyncio
async def test_job_dedupe_released_on_terminal():
repos = await _make_repos()
try:
job, _ = await repos["jobs"].try_create_or_get_active(id="drj_1", session_id="drs_1", user_id="u1")
assert job["active_dedupe_key"] is not None
await repos["jobs"].update_progress("drj_1", lease_owner=None, user_id="u1", status="completed")
job2, created2 = await repos["jobs"].try_create_or_get_active(id="drj_2", session_id="drs_1", user_id="u1")
assert created2 is True
assert job2["id"] == "drj_2"
finally:
await repos["_engine"].dispose()
# ── jobs: lease mechanics ───────────────────────────────────────────────────
@pytest.mark.asyncio
async def test_job_claim_succeeds_for_queued():
repos = await _make_repos()
try:
await repos["jobs"].try_create_or_get_active(id="drj_1", session_id="drs_1", user_id="u1")
lease_until = datetime.now(UTC) + timedelta(seconds=60)
claimed = await repos["jobs"].claim_job("drj_1", lease_owner="w1", lease_until=lease_until)
assert claimed is not None
assert claimed["status"] == "running"
assert claimed["lease_owner"] == "w1"
assert claimed["attempt"] == 1
finally:
await repos["_engine"].dispose()
@pytest.mark.asyncio
async def test_dispatcher_claims_queued_job_and_starts_report_worker():
"""The claimed snapshot must reach the executor before the job can run."""
from app.gateway.deep_research_job_dispatcher import DeepResearchJobDispatcher
class _Executor:
def __init__(self) -> None:
self.started: list[tuple[dict, str, str | None]] = []
def start_job(self, snapshot: dict, *, job_id: str, lease_owner: str | None) -> bool:
self.started.append((snapshot, job_id, lease_owner))
return True
repos = await _make_repos()
try:
await repos["jobs"].try_create_or_get_active(
id="drj_1",
session_id="drs_1",
user_id="u1",
input_snapshot={"query": "测试报告"},
)
runner = _Executor()
dispatcher = DeepResearchJobDispatcher(repos["jobs"], runner, worker_id="worker_1")
started = await dispatcher.dispatch_once()
assert started == 1
assert runner.started == [({"query": "测试报告"}, "drj_1", "worker_1")]
finally:
await repos["_engine"].dispose()
@pytest.mark.asyncio
async def test_job_claim_fails_if_already_claimed():
repos = await _make_repos()
try:
await repos["jobs"].try_create_or_get_active(id="drj_1", session_id="drs_1", user_id="u1")
lease_until = datetime.now(UTC) + timedelta(seconds=60)
first = await repos["jobs"].claim_job("drj_1", lease_owner="w1", lease_until=lease_until)
assert first is not None
second = await repos["jobs"].claim_job("drj_1", lease_owner="w2", lease_until=lease_until)
assert second is None
finally:
await repos["_engine"].dispose()
@pytest.mark.asyncio
async def test_job_renew_lease_only_by_owner():
repos = await _make_repos()
try:
await repos["jobs"].try_create_or_get_active(id="drj_1", session_id="drs_1", user_id="u1")
lease_until = datetime.now(UTC) + timedelta(seconds=60)
await repos["jobs"].claim_job("drj_1", lease_owner="w1", lease_until=lease_until)
assert await repos["jobs"].renew_lease("drj_1", lease_owner="w1", lease_until=lease_until) is True
assert await repos["jobs"].renew_lease("drj_1", lease_owner="w2", lease_until=lease_until) is False
finally:
await repos["_engine"].dispose()
@pytest.mark.asyncio
async def test_job_expired_lease_reclaimable():
repos = await _make_repos()
try:
await repos["jobs"].try_create_or_get_active(id="drj_1", session_id="drs_1", user_id="u1")
expired = datetime.now(UTC) - timedelta(seconds=10)
await repos["jobs"].claim_job("drj_1", lease_owner="w1", lease_until=expired)
now = datetime.now(UTC)
claimable = await repos["jobs"].list_claimable(now=now)
assert "drj_1" in claimable
reclaimed = await repos["jobs"].claim_job("drj_1", lease_owner="w2", lease_until=now + timedelta(seconds=60))
assert reclaimed is not None
assert reclaimed["lease_owner"] == "w2"
finally:
await repos["_engine"].dispose()
# ── jobs: two-phase cancel ──────────────────────────────────────────────────
@pytest.mark.asyncio
async def test_job_cancel_two_phase():
repos = await _make_repos()
try:
await repos["jobs"].try_create_or_get_active(id="drj_1", session_id="drs_1", user_id="u1")
lease_until = datetime.now(UTC) + timedelta(seconds=60)
await repos["jobs"].claim_job("drj_1", lease_owner="w1", lease_until=lease_until)
requested = await repos["jobs"].request_cancel("drj_1", user_id="u1")
assert requested is not None
assert requested["cancel_requested"] is True
finalized = await repos["jobs"].finalize_cancel("drj_1")
assert finalized is not None
assert finalized["status"] == "cancelled"
assert finalized["active_dedupe_key"] is None
finally:
await repos["_engine"].dispose()
@pytest.mark.asyncio
async def test_job_cancel_idempotent():
repos = await _make_repos()
try:
await repos["jobs"].try_create_or_get_active(id="drj_1", session_id="drs_1", user_id="u1")
first = await repos["jobs"].request_cancel("drj_1", user_id="u1")
assert first is not None
await repos["jobs"].finalize_cancel("drj_1")
second = await repos["jobs"].request_cancel("drj_1", user_id="u1")
assert second is None
finally:
await repos["_engine"].dispose()
# ── jobs: progress update with lease gate ───────────────────────────────────
@pytest.mark.asyncio
async def test_job_update_progress_lease_gated():
repos = await _make_repos()
try:
await repos["jobs"].try_create_or_get_active(id="drj_1", session_id="drs_1", user_id="u1")
lease_until = datetime.now(UTC) + timedelta(seconds=60)
await repos["jobs"].claim_job("drj_1", lease_owner="w1", lease_until=lease_until)
updated = await repos["jobs"].update_progress("drj_1", lease_owner="w1", phase="collecting", progress=50)
assert updated is not None
assert updated["phase"] == "collecting"
assert updated["progress"] == 50
rejected = await repos["jobs"].update_progress("drj_1", lease_owner="w2", phase="writing")
assert rejected is None
finally:
await repos["_engine"].dispose()
# ── events: monotonic seq + replay ──────────────────────────────────────────
@pytest.mark.asyncio
async def test_event_seq_monotonic():
repos = await _make_repos()
try:
repo = repos["events"]
e1 = await repo.append(session_id="drs_1", job_id="drj_1", event_type="phase_changed", payload={"to": "planning"})
e2 = await repo.append(session_id="drs_1", job_id="drj_1", event_type="source_added", payload={"id": "s1"})
e3 = await repo.append(session_id="drs_1", job_id="drj_1", event_type="source_added", payload={"id": "s2"})
assert e1["seq"] == 1
assert e2["seq"] == 2
assert e3["seq"] == 3
assert await repo.last_seq("drj_1") == 3
finally:
await repos["_engine"].dispose()
@pytest.mark.asyncio
async def test_event_append_never_reads_back_after_commit(monkeypatch):
"""Event persistence must work when a post-commit read hits a lagging replica."""
from sqlalchemy.ext.asyncio import AsyncSession
async def fail_refresh(self, instance, *args, **kwargs): # noqa: ANN001, ARG001
raise AssertionError("DeepResearchEventRepository must not call session.refresh")
monkeypatch.setattr(AsyncSession, "refresh", fail_refresh)
repos = await _make_repos()
try:
event = await repos["events"].append(
session_id="drs_1",
job_id="drj_1",
event_type="phase_changed",
payload={"to": "planning"},
)
assert event["id"] is not None
assert event["seq"] == 1
finally:
await repos["_engine"].dispose()
@pytest.mark.asyncio
async def test_event_list_after_replay():
repos = await _make_repos()
try:
repo = repos["events"]
for i in range(5):
await repo.append(session_id="drs_1", job_id="drj_1", event_type="heartbeat", payload={"i": i})
replayed = await repo.list_after("drj_1", after=2)
assert len(replayed) == 3
assert [e["seq"] for e in replayed] == [3, 4, 5]
finally:
await repos["_engine"].dispose()
@pytest.mark.asyncio
async def test_event_payload_round_trip():
repos = await _make_repos()
try:
repo = repos["events"]
await repo.append(
session_id="drs_1",
job_id="drj_1",
event_type="plan_created",
payload={"subtopics": ["AI", "ML"], "nested": {"a": 1}},
)
events = await repo.list_after("drj_1", after=0)
assert events[0]["payload"]["subtopics"] == ["AI", "ML"]
assert events[0]["payload"]["nested"]["a"] == 1
finally:
await repos["_engine"].dispose()
@pytest.mark.asyncio
async def test_event_seq_independent_per_job():
repos = await _make_repos()
try:
repo = repos["events"]
await repo.append(session_id="drs_1", job_id="drj_1", event_type="heartbeat")
await repo.append(session_id="drs_1", job_id="drj_1", event_type="heartbeat")
await repo.append(session_id="drs_1", job_id="drj_2", event_type="heartbeat")
assert await repo.last_seq("drj_1") == 2
assert await repo.last_seq("drj_2") == 1
finally:
await repos["_engine"].dispose()
# ── sources ─────────────────────────────────────────────────────────────────
@pytest.mark.asyncio
async def test_source_upsert_and_list():
repos = await _make_repos()
try:
await repos["sources"].upsert(
session_id="drs_1",
id="src_1",
user_id="u1",
title="Source A",
url="https://example.com/a",
raw_content="content A",
source="web",
source_type="web",
content_hash="hash_a",
)
items = await repos["sources"].list_by_session("drs_1", user_id="u1")
assert len(items) == 1
assert items[0]["title"] == "Source A"
assert "raw_content" not in items[0]
finally:
await repos["_engine"].dispose()
@pytest.mark.asyncio
async def test_source_set_selected():
repos = await _make_repos()
try:
await repos["sources"].upsert(
session_id="drs_1",
id="src_1",
user_id="u1",
title="A",
raw_content="c",
source="web",
content_hash="h",
)
updated = await repos["sources"].set_selected("src_1", selected=True, reason="relevant", citation_key="1", user_id="u1")
assert updated["selected"] is True
assert updated["citation_key"] == "1"
finally:
await repos["_engine"].dispose()
# ── messages ────────────────────────────────────────────────────────────────
@pytest.mark.asyncio
async def test_message_append_and_list():
repos = await _make_repos()
try:
await repos["messages"].append(id="msg_1", session_id="drs_1", user_id="u1", role="user", content="question?")
await repos["messages"].append(
id="msg_2",
session_id="drs_1",
user_id="u1",
role="assistant",
content="answer",
citation_source_ids=["src_1"],
)
msgs = await repos["messages"].list_by_session("drs_1", user_id="u1")
assert len(msgs) == 2
assert msgs[0]["role"] == "user"
assert msgs[1]["citation_source_ids"] == ["src_1"]
finally:
await repos["_engine"].dispose()
@@ -0,0 +1,583 @@
"""Regression coverage for idempotent Deep Research job submission."""
import json
from datetime import UTC, datetime
from types import SimpleNamespace
import pytest
from app.gateway import deep_research_report_rewrite as report_rewrite
from app.gateway.routers import deep_research
class _SessionStore:
def __init__(self) -> None:
self.updates: list[dict] = []
async def get(self, session_id: str, *, user_id: str): # noqa: ARG002
return {
"id": session_id,
"query": "测试主题",
"title": "测试主题",
"config_snapshot": {"mode": "basic"},
}
async def count_active_by_user(self, *, user_id: str) -> int: # noqa: ARG002
return 0
async def update(self, session_id: str, *, user_id: str, **fields): # noqa: ARG002
self.updates.append(fields)
return {"id": session_id, **fields}
class _JobStore:
async def get_active_for_session(self, session_id: str, *, user_id: str): # noqa: ARG002
return None
async def try_create_or_get_active(self, **kwargs): # noqa: ANN003
# Simulate a retry after an earlier request committed the job but did
# not finish responding to the browser.
return {"id": "drj_existing", "status": "queued"}, False
class _Dispatcher:
def __init__(self) -> None:
self.nudges = 0
def nudge(self) -> None:
self.nudges += 1
def _request(*, sessions, jobs, dispatcher, sources=None):
return SimpleNamespace(
app=SimpleNamespace(
state=SimpleNamespace(
deep_research_session_store=sessions,
deep_research_job_store=jobs,
deep_research_dispatcher=dispatcher,
deep_research_source_store=sources,
)
)
)
@pytest.mark.asyncio
async def test_retry_of_existing_queued_job_nudges_dispatcher(monkeypatch):
"""An idempotent retry must recover a queued-but-not-yet-dispatched job."""
async def fake_require_user(request): # noqa: ANN001
return "u1"
monkeypatch.setattr(deep_research, "_require_user", fake_require_user)
sessions = _SessionStore()
dispatcher = _Dispatcher()
request = _request(sessions=sessions, jobs=_JobStore(), dispatcher=dispatcher)
response = await deep_research.start_job(
"drs_1",
deep_research.StartJobRequest(entry="legacy"),
request,
)
assert response == {
"jobId": "drj_existing",
"sessionId": "drs_1",
"status": "queued",
"reused": True,
}
assert dispatcher.nudges == 1
assert sessions.updates == [{"status": "running", "active_job_id": "drj_existing"}]
@pytest.mark.asyncio
async def test_queued_job_still_starts_when_session_projection_temporarily_fails(monkeypatch):
"""A committed job is more important than its non-authoritative UI projection."""
async def fake_require_user(request): # noqa: ANN001
return "u1"
class _ProjectionFailureSessionStore(_SessionStore):
async def update(self, session_id: str, *, user_id: str, **fields): # noqa: ARG002
raise RuntimeError("temporary database readback failure")
class _NewJobStore(_JobStore):
async def try_create_or_get_active(self, **kwargs): # noqa: ANN003
return {"id": "drj_new", "status": "queued"}, True
monkeypatch.setattr(deep_research, "_require_user", fake_require_user)
dispatcher = _Dispatcher()
response = await deep_research.start_job(
"drs_1",
deep_research.StartJobRequest(entry="legacy"),
_request(
sessions=_ProjectionFailureSessionStore(),
jobs=_NewJobStore(),
dispatcher=dispatcher,
),
)
assert response["jobId"] == "drj_new"
assert response["reused"] is False
assert dispatcher.nudges == 1
@pytest.mark.asyncio
async def test_chat_report_card_can_enable_images_after_collection(monkeypatch):
"""The write-time card override must win over the collection-time default."""
async def fake_require_user(request): # noqa: ANN001
return "u1"
class _ChatSessionStore(_SessionStore):
async def get(self, session_id: str, *, user_id: str): # noqa: ARG002
return {
"id": session_id,
"query": "测试主题",
"title": "测试主题",
"runtime_thread_id": "collector-thread",
"config_snapshot": {
"mode": "basic",
"collection_mode": "chat",
"generate_images": False,
"max_generated_images": 2,
},
}
class _CapturingJobStore(_JobStore):
def __init__(self) -> None:
self.created: dict | None = None
async def try_create_or_get_active(self, **kwargs): # noqa: ANN003
self.created = kwargs
return {"id": "drj_images", "status": "queued"}, True
monkeypatch.setattr(deep_research, "_require_user", fake_require_user)
sessions = _ChatSessionStore()
jobs = _CapturingJobStore()
response = await deep_research.start_job(
"drs_1",
deep_research.StartJobRequest(
entry="chat",
config={"generate_images": True, "max_generated_images": 3},
),
_request(sessions=sessions, jobs=jobs, dispatcher=_Dispatcher()),
)
assert response["jobId"] == "drj_images"
assert jobs.created is not None
snapshot = jobs.created["input_snapshot"]["config"]
assert snapshot["generate_images"] is True
assert snapshot["max_generated_images"] == 3
# The session snapshot is persisted too, so a reload/replay keeps the
# write-time choice instead of reverting to the creation-time false.
assert any(
update.get("config_snapshot", {}).get("generate_images") is True
for update in sessions.updates
)
@pytest.mark.asyncio
async def test_report_variant_uses_normal_job_with_selected_sources(monkeypatch):
"""Regeneration must queue the original report engine, never a rewrite job."""
async def fake_require_user(request): # noqa: ANN001
return "u1"
class _VariantSessionStore(_SessionStore):
async def get(self, session_id: str, *, user_id: str): # noqa: ARG002
return {
"id": session_id,
"query": "新能源汽车市场",
"title": "新能源汽车市场 · 新结构报告",
"status": "draft",
"runtime_thread_id": "dr_variant_thread",
"config_snapshot": {
"mode": "basic",
"collection_mode": "chat",
"report_variant": True,
"parent_session_id": "drs_parent",
},
}
class _SelectedSources:
async def count_by_session(self, *args, **kwargs): # noqa: ANN002, ANN003
return 12
class _CapturingJobStore(_JobStore):
def __init__(self) -> None:
self.created: dict | None = None
async def try_create_or_get_active(self, **kwargs): # noqa: ANN003
self.created = kwargs
return {"id": "drj_regenerate", "status": "queued"}, True
monkeypatch.setattr(deep_research, "_require_user", fake_require_user)
sessions = _VariantSessionStore()
jobs = _CapturingJobStore()
response = await deep_research.start_job(
"drs_variant",
deep_research.StartJobRequest(
entry="regenerate",
config={
"custom_outline": "# 新结构\n\n## 第四章",
"report_instruction": "统一表达并保留可核验事实。",
},
),
_request(
sessions=sessions,
jobs=jobs,
dispatcher=_Dispatcher(),
sources=_SelectedSources(),
),
)
assert response["jobId"] == "drj_regenerate"
snapshot = jobs.created["input_snapshot"]
assert snapshot["entry"] == "regenerate"
assert snapshot["config"]["custom_outline"].endswith("## 第四章")
assert snapshot["config"]["report_instruction"] == "统一表达并保留可核验事实。"
assert "report_variant" not in snapshot["config"]
assert "parent_session_id" not in snapshot["config"]
assert any(
update.get("config_snapshot", {}).get("report_variant") is True
for update in sessions.updates
)
assert any(
update.get("config_snapshot", {}).get("parent_session_id") == "drs_parent"
for update in sessions.updates
)
@pytest.mark.asyncio
async def test_stream_stays_open_when_durable_replay_has_a_transient_failure(monkeypatch):
"""A stream DB blip must yield a recoverable warning, not an ASGI error group."""
async def fake_require_user(request): # noqa: ANN001
return "u1"
class _StreamJobStore:
async def get(self, job_id: str, *, user_id: str): # noqa: ARG002
return {"id": job_id, "session_id": "drs_1"}
async def get_unscoped(self, job_id: str): # noqa: ARG002
return None
class _UnavailableEventStore:
async def list_after(self, *args, **kwargs): # noqa: ANN002, ANN003
raise RuntimeError("temporary replica failure")
async def is_connected() -> bool:
return False
monkeypatch.setattr(deep_research, "_require_user", fake_require_user)
request = SimpleNamespace(
app=SimpleNamespace(
state=SimpleNamespace(
deep_research_job_store=_StreamJobStore(),
deep_research_event_store=_UnavailableEventStore(),
)
),
is_disconnected=is_connected,
)
response = await deep_research.stream_job("drj_1", request)
chunk = await anext(response.body_iterator)
await response.body_iterator.aclose()
assert "durable_replay_temporarily_unavailable" in chunk
@pytest.mark.asyncio
async def test_full_report_rewrite_persists_selected_report_structure(monkeypatch):
"""A selected structure must survive durable replay and constrain the worker."""
async def fake_require_user(request): # noqa: ANN001
return "u1"
class _CompletedSessionStore(_SessionStore):
async def get(self, session_id: str, *, user_id: str): # noqa: ARG002
return {
"id": session_id,
"query": "测试主题",
"title": "测试主题",
"status": "completed",
"report_markdown": "# 原报告\n\n原有内容。",
"config_snapshot": {"mode": "basic"},
}
class _SourceStore:
async def list_by_session(self, *args, **kwargs): # noqa: ANN002, ANN003
# SQL-backed historical sources return native datetimes, whereas
# the job snapshot is persisted as a JSON column.
return [{"id": "src_1", "created_at": datetime(2026, 8, 21, tzinfo=UTC)}]
class _CapturingJobStore(_JobStore):
def __init__(self) -> None:
self.created: dict | None = None
async def try_create_or_get_active(self, **kwargs): # noqa: ANN003
# Match the repository's JSON persistence boundary. This used to
# raise TypeError for historical source rows with datetime fields.
json.dumps(kwargs["input_snapshot"], ensure_ascii=False)
self.created = kwargs
return {"id": "drj_rewrite", "status": "queued"}, True
monkeypatch.setattr(deep_research, "_require_user", fake_require_user)
jobs = _CapturingJobStore()
outline = "# 执行摘要\n\n# 一、核心发现\n\n# 二、行动建议"
response = await deep_research.start_full_report_rewrite_job(
"drs_1",
deep_research.FullReportRewriteRequest(
instruction="压缩重复段落,保持事实准确。",
reportOutline=outline,
operation="generate",
),
_request(
sessions=_CompletedSessionStore(),
jobs=jobs,
dispatcher=_Dispatcher(),
sources=_SourceStore(),
),
)
assert response["jobId"] == "drj_rewrite"
assert jobs.created is not None
snapshot = jobs.created["input_snapshot"]
assert snapshot["operation"] == "generate"
assert snapshot["report_outline"] == outline
assert "【报告结构要求】" in snapshot["instruction"]
assert "# 一、核心发现" in snapshot["instruction"]
assert snapshot["sources"][0]["created_at"] == "2026-08-21T00:00:00+00:00"
@pytest.mark.asyncio
async def test_regeneration_forks_report_and_selected_sources(monkeypatch):
"""Choosing another structure must never mutate the completed parent report."""
async def fake_require_user(request): # noqa: ANN001
return "u1"
class _VariantSessionStore:
def __init__(self) -> None:
self.parent = {
"id": "drs_parent",
"user_id": "u1",
"title": "新能源研究",
"query": "新能源市场",
"mode": "basic",
"status": "completed",
"report_markdown": (
"# 原报告\n\n"
"已保存引用 [来源:src_parent];"
"流式引用 [[source:src_parent]];"
"已取消的资料 [[source:src_unselected]]。"
),
"config_snapshot": {"mode": "basic", "custom_outline": "# 原结构"},
"source_count": 1,
}
self.created: dict | None = None
self.updated: dict | None = None
self.deleted: list[str] = []
async def get(self, session_id: str, *, user_id: str): # noqa: ARG002
return self.parent if session_id == "drs_parent" else None
async def create(self, **fields): # noqa: ANN003
self.created = fields
return {**fields, "report_markdown": None, "source_count": 0}
async def update(self, session_id: str, *, user_id: str, **fields): # noqa: ARG002
self.updated = {"session_id": session_id, **fields}
return {
"id": session_id,
"user_id": "u1",
"title": self.created["title"] if self.created else "",
"query": "新能源市场",
"mode": "basic",
"status": self.created["status"] if self.created else "draft",
"config_snapshot": self.created["config_snapshot"] if self.created else {},
**fields,
}
async def delete(self, session_id: str, *, user_id: str): # noqa: ARG002
self.deleted.append(session_id)
return True
class _VariantSourceStore:
async def clone_selected_to_session(self, source_session_id: str, target_session_id: str, *, user_id: str): # noqa: ARG002
assert source_session_id == "drs_parent"
assert target_session_id.startswith("drs_")
return {"src_parent": "src_variant"}
monkeypatch.setattr(deep_research, "_require_user", fake_require_user)
async def fake_ensure_runtime_thread(request, session, user_id): # noqa: ANN001, ARG001
await sessions.update(session["id"], user_id=user_id, runtime_thread_id="dr_variant_thread")
sessions = _VariantSessionStore()
monkeypatch.setattr(deep_research, "_ensure_chat_runtime_thread", fake_ensure_runtime_thread)
response = await deep_research.create_report_variant(
"drs_parent",
deep_research.CreateReportVariantRequest(reportOutline="# 新结构\n\n## 结论"),
_request(
sessions=sessions,
jobs=_JobStore(),
dispatcher=_Dispatcher(),
sources=_VariantSourceStore(),
),
)
assert response.id != "drs_parent"
assert response.title == "新能源研究 · 新结构报告"
assert response.report_markdown is None
assert response.status == "draft"
assert response.config == {
"mode": "basic",
"custom_outline": "# 新结构\n\n## 结论",
"report_variant": True,
"parent_session_id": "drs_parent",
}
assert sessions.parent["report_markdown"] == (
"# 原报告\n\n"
"已保存引用 [来源:src_parent];"
"流式引用 [[source:src_parent]];"
"已取消的资料 [[source:src_unselected]]。"
)
assert sessions.updated is not None
assert sessions.updated["source_count"] == 1
assert sessions.deleted == []
def test_normalise_citations_accepts_display_ready_and_legacy_markers() -> None:
source_ids = {"drs_src_1234567890abcdef1234567890abcdef"}
result, cited = report_rewrite._normalise_citations( # noqa: SLF001
"甲[来源:drs_src_1234567890abcdef1234567890abcdef];"
"乙[[source:drs_src_1234567890abcdef1234567890abcdef]];"
"丙[来源: drs_src_1234567890abcdef1234567890abcdef]。",
source_ids,
)
assert result == (
"甲[来源:drs_src_1234567890abcdef1234567890abcdef];"
"乙[来源:drs_src_1234567890abcdef1234567890abcdef];"
"丙[来源:drs_src_1234567890abcdef1234567890abcdef]。"
)
assert cited == ["drs_src_1234567890abcdef1234567890abcdef"]
def test_normalise_citations_repairs_unique_truncated_selected_id() -> None:
full_id = "drs_src_ac653c4a6f364e59a30b044e98d32e2f"
result, cited = report_rewrite._normalise_citations( # noqa: SLF001
"事实[来源:drs_src_ac653c4a6f364e59a30b044e98d32e]。",
{full_id},
)
assert result == f"事实[来源:{full_id}]。"
assert cited == [full_id]
def test_normalise_citations_still_rejects_unknown_source() -> None:
with pytest.raises(ValueError, match="未选资料来源"):
report_rewrite._normalise_citations( # noqa: SLF001
"事实[来源:drs_src_ffffffffffffffffffffffffffffffff]。",
{"drs_src_ac653c4a6f364e59a30b044e98d32e2f"},
)
def test_normalise_citations_removes_provider_truncated_marker_without_discarding_report() -> None:
result, cited = report_rewrite._normalise_citations( # noqa: SLF001
"# 参考资料\n\n已完成的正文。\n[来源:drs_src_ac653c4a6f364e59a30b044e98d32",
{"drs_src_ac653c4a6f364e59a30b044e98d32e2f"},
)
assert result == "# 参考资料\n\n已完成的正文。"
assert cited == []
@pytest.mark.asyncio
async def test_generate_operation_uses_selected_sources_not_inherited_report(monkeypatch) -> None:
captured: dict = {}
class _CompletionBackend:
def __init__(self, config) -> None: # noqa: ANN001
captured["config"] = config
async def stream_complete(self, **kwargs): # noqa: ANN003
captured.update(kwargs)
return SimpleNamespace(
text=(
"# 新报告\n\n事实[来源:drs_src_1234567890abcdef1234567890abcdef]。\n\n"
"<!-- DEERFLOW_REPORT_COMPLETE -->"
),
usage={},
)
monkeypatch.setattr(report_rewrite, "DeerFlowCompletionBackend", _CompletionBackend)
async def _ignore(_delta: str) -> None:
return None
result, cited, _usage = await report_rewrite.stream_full_report_rewrite(
session={"config_snapshot": {"mode": "basic"}, "query": "新能源汽车"},
report="# 不应进入模型的旧报告\n\n旧结构和旧措辞。",
sources=[
{
"id": "drs_src_1234567890abcdef1234567890abcdef",
"title": "已选资料",
"raw_content": "可核验事实",
}
],
instruction="按新结构生成",
style="formal_analysis",
model_name=None,
on_delta=_ignore,
operation="generate",
)
prompt = "\n".join(str(message["content"]) for message in captured["messages"])
assert "不应进入模型的旧报告" not in prompt
assert "# 已选来源" in prompt
assert captured["operation"] == "full_report_generate"
assert captured["max_tokens"] == 8_192
assert result.endswith("[来源:drs_src_1234567890abcdef1234567890abcdef]。")
assert cited == ["drs_src_1234567890abcdef1234567890abcdef"]
@pytest.mark.asyncio
async def test_report_generation_continues_when_first_segment_has_no_completion_marker(monkeypatch) -> None:
calls: list[str] = []
class _CompletionBackend:
def __init__(self, _config) -> None: # noqa: ANN001
pass
async def stream_complete(self, **kwargs): # noqa: ANN003
calls.append(str(kwargs["operation"]))
if len(calls) == 1:
return SimpleNamespace(text="# 新报告\n\n第一部分。", usage={"completion_tokens": 100})
return SimpleNamespace(
text="## 第二部分\n\n续写完成。\n\n<!-- DEERFLOW_REPORT_COMPLETE -->",
usage={"completion_tokens": 50},
)
monkeypatch.setattr(report_rewrite, "DeerFlowCompletionBackend", _CompletionBackend)
async def _ignore(_delta: str) -> None:
return None
result, cited, usage = await report_rewrite.stream_full_report_rewrite(
session={"config_snapshot": {"mode": "basic"}, "query": "新能源汽车"},
report="# 旧报告",
sources=[],
instruction="按新结构生成",
style="formal_analysis",
model_name=None,
on_delta=_ignore,
operation="generate",
)
assert calls == ["full_report_generate", "full_report_generate_continue"]
assert result == "# 新报告\n\n第一部分。\n\n## 第二部分\n\n续写完成。"
assert cited == []
assert usage["completion_tokens"] == 150
@@ -0,0 +1,396 @@
"""Regression tests for owner-scoped enterprise-research task persistence."""
from __future__ import annotations
import asyncio
from types import SimpleNamespace
import pytest
import pytest_asyncio
from fastapi import FastAPI
from httpx import ASGITransport, AsyncClient
from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
from deerflow.persistence.base import Base
from deerflow.persistence.enterprise_research import (
EnterpriseResearchReportJobRepository,
EnterpriseResearchTaskRepository,
MemoryEnterpriseResearchReportJobStore,
MemoryEnterpriseResearchTaskStore,
make_enterprise_research_task_store,
)
@pytest_asyncio.fixture
async def store(tmp_path):
engine = create_async_engine(f"sqlite+aiosqlite:///{tmp_path / 'enterprise-research.db'}")
async with engine.begin() as conn:
import deerflow.persistence.enterprise_research.model # noqa: F401
await conn.run_sync(Base.metadata.create_all)
return EnterpriseResearchTaskRepository(async_sessionmaker(engine, expire_on_commit=False))
async def _create(store, *, task_id: str, user_id: str = "u1"):
return await store.create_task(
{
"id": task_id,
"user_id": user_id,
"subject": "新能源汽车供应链风险",
"focus": "关键原材料",
"template_id": "topic",
"knowledge_base_ids": ["kb-1"],
"queries": ["新能源汽车供应链风险", "关键原材料"],
"status": "draft",
}
)
@pytest.mark.asyncio
async def test_task_evidence_roundtrip_and_owner_isolation(store: EnterpriseResearchTaskRepository):
created = await _create(store, task_id="ert-1")
assert created["sources"] == []
assert created["status"] == "draft"
updated = await store.update_task(
"ert-1",
"u1",
{
"status": "ready",
"selected_source_ids": ["chunk-1"],
"plan_markdown": "# 供应链风险研究计划",
"sources": [
{
"chunk_id": "chunk-1",
"title": "供应链报告",
"content": "证据内容",
"knowledge_base_id": "kb-1",
}
],
},
)
assert updated is not None
assert updated["status"] == "ready"
assert updated["sources"][0]["chunk_id"] == "chunk-1"
assert updated["selected_source_ids"] == ["chunk-1"]
assert updated["plan_markdown"] == "# 供应链风险研究计划"
assert await store.get_task("ert-1", "u2") is None
assert await store.update_task("ert-1", "u2", {"status": "failed"}) is None
@pytest.mark.asyncio
async def test_list_is_owner_scoped_and_delete_requires_owner(store: EnterpriseResearchTaskRepository):
await _create(store, task_id="ert-u1", user_id="u1")
await _create(store, task_id="ert-u2", user_id="u2")
assert [task["id"] for task in await store.list_tasks("u1")] == ["ert-u1"]
assert await store.delete_task("ert-u1", "u2") is False
assert await store.delete_task("ert-u1", "u1") is True
assert await store.get_task("ert-u1", "u1") is None
@pytest.mark.asyncio
async def test_memory_store_matches_sql_contract():
store = make_enterprise_research_task_store(None)
assert isinstance(store, MemoryEnterpriseResearchTaskStore)
await _create(store, task_id="memory-1")
assert (await store.get_task("memory-1", "u1"))["subject"] == "新能源汽车供应链风险"
assert await store.delete_task("memory-1", "u1") is True
@pytest.mark.asyncio
async def test_report_job_freezes_sources_and_is_owner_scoped(tmp_path):
engine = create_async_engine(f"sqlite+aiosqlite:///{tmp_path / 'enterprise-report-job.db'}")
async with engine.begin() as conn:
import deerflow.persistence.enterprise_research.model # noqa: F401
await conn.run_sync(Base.metadata.create_all)
jobs = EnterpriseResearchReportJobRepository(async_sessionmaker(engine, expire_on_commit=False))
created = await jobs.create_job(
{
"id": "erj-1", "task_id": "ert-1", "user_id": "u1", "plan_snapshot": "# 计划",
"sources": [{"chunk_id": "source-1", "content": "冻结证据"}],
"action": "rewrite", "instruction": "优化结构", "original_report": "# 原报告",
}
)
assert created["status"] == "queued"
assert created["sources"][0]["content"] == "冻结证据"
assert created["action"] == "rewrite"
assert created["original_report"] == "# 原报告"
deduplicated = await jobs.create_job(
{
"id": "erj-duplicate", "task_id": "ert-1", "user_id": "u1", "plan_snapshot": "# 其他计划",
"sources": [], "action": "initial",
}
)
assert deduplicated["id"] == "erj-1"
assert await jobs.get_job("erj-1", "u2") is None
assert (await jobs.get_active_for_task("ert-1", "u1"))["id"] == "erj-1"
assert await jobs.claim_job("erj-1", "u1") is True
assert await jobs.claim_job("erj-1", "u1") is False
running = (await jobs.list_recoverable())[0]
assert running["status"] == "running"
assert await jobs.requeue_job("erj-1", "u1", expected_updated_at="stale-snapshot") is False
assert await jobs.requeue_job("erj-1", "u1", expected_updated_at=running["updated_at"]) is True
assert await jobs.requeue_job("erj-1", "u1", expected_updated_at=running["updated_at"]) is False
assert await jobs.claim_job("erj-1", "u1") is True
completed = await jobs.transition_job(
"erj-1", "u1", expected_statuses={"running"},
data={"status": "completed", "phase": "completed", "report_markdown": "# 报告"},
)
assert completed is not None and completed["report_markdown"] == "# 报告"
assert await jobs.transition_job(
"erj-1", "u1", expected_statuses={"running"}, data={"status": "cancelled"}
) is None
assert await jobs.get_active_for_task("ert-1", "u1") is None
next_job = await jobs.create_job(
{"id": "erj-2", "task_id": "ert-1", "user_id": "u1", "plan_snapshot": "# 新计划", "sources": []}
)
assert next_job["id"] == "erj-2"
@pytest.mark.asyncio
async def test_memory_report_job_store_has_matching_owner_contract():
jobs = MemoryEnterpriseResearchReportJobStore()
await jobs.create_job({"id": "memory-job", "task_id": "task", "user_id": "u1", "plan_snapshot": "x"})
assert await jobs.get_job("memory-job", "u2") is None
assert (await jobs.list_jobs("task", "u1"))[0]["id"] == "memory-job"
assert await jobs.claim_job("memory-job", "u1") is True
assert await jobs.claim_job("memory-job", "u1") is False
running = await jobs.get_job("memory-job", "u1")
assert running is not None
assert await jobs.requeue_job("memory-job", "u1", expected_updated_at=running["updated_at"]) is True
assert await jobs.claim_job("memory-job", "u1") is True
completed = await jobs.transition_job(
"memory-job", "u1", expected_statuses={"running"}, data={"status": "completed", "phase": "completed"}
)
assert completed is not None and completed["status"] == "completed"
def test_evidence_snapshot_deduplicates_and_never_exposes_unmapped_remote_bases():
from app.gateway.routers.enterprise_research import _dedupe_evidence
mappings = {"remote-kb-1": {"id": "local-kb-1", "name": "用户可见知识库", "weknora_id": "remote-kb-1"}}
evidence = _dedupe_evidence(
[
{"chunk_id": "chunk-1", "content": "第一段", "knowledge_base_id": "remote-kb-1", "title": "文档 A"},
{"chunk_id": "chunk-1", "content": "重复段", "knowledge_base_id": "remote-kb-1", "title": "文档 A"},
{"chunk_id": "private-chunk", "content": "不应显示", "knowledge_base_id": "other-user-kb", "title": "私有文档"},
],
mappings,
)
assert len(evidence) == 1
assert evidence[0]["knowledge_base_id"] == "local-kb-1"
assert "other-user-kb" not in str(evidence)
def test_report_executor_uses_distinct_initial_rewrite_and_followup_prompts():
from app.gateway.enterprise_research_report_executor import EnterpriseResearchReportExecutor
base = {
"plan_snapshot": "# 计划",
"sources": [{"chunk_id": "source-1", "title": "内部资料", "content": "证据正文"}],
"original_report": "# 原报告\n原始正文",
"instruction": "压缩重复段落",
"target_length": 3_000,
"style": "analytical",
}
initial = EnterpriseResearchReportExecutor._messages({**base, "action": "initial"})
rewrite = EnterpriseResearchReportExecutor._messages({**base, "action": "rewrite"})
followup = EnterpriseResearchReportExecutor._messages({**base, "action": "followup"})
assert "完整 Markdown 报告" in initial[0]["content"]
assert "原报告" not in initial[1]["content"]
assert "全文改写" in rewrite[1]["content"] and "# 原报告" in rewrite[1]["content"]
assert "不要重写整篇报告" in followup[0]["content"]
assert "压缩重复段落" in followup[1]["content"]
summary = EnterpriseResearchReportExecutor._summary(
"# 新报告\n\n新正文", 2, "rewrite", original_report="# 旧报告\n\n旧正文", instruction="调整结构"
)
assert "原文" in summary and "标题节点 1→1" in summary and "调整结构" in summary
@pytest.mark.asyncio
async def test_executor_recovery_requeues_exact_running_snapshot(monkeypatch):
from app.gateway.enterprise_research_report_executor import EnterpriseResearchReportExecutor
tasks = MemoryEnterpriseResearchTaskStore()
jobs = MemoryEnterpriseResearchReportJobStore()
await jobs.create_job({"id": "recover-job", "task_id": "task", "user_id": "u1", "plan_snapshot": "# 计划"})
assert await jobs.claim_job("recover-job", "u1") is True
executor = EnterpriseResearchReportExecutor(tasks, jobs)
started: list[tuple[str, str]] = []
async def remember(job_id: str, user_id: str) -> None:
started.append((job_id, user_id))
monkeypatch.setattr(executor, "ensure_started", remember)
await executor.recover_pending()
recovered = await jobs.get_job("recover-job", "u1")
assert recovered is not None and recovered["status"] == "queued"
assert started == [("recover-job", "u1")]
@pytest.mark.asyncio
async def test_enterprise_research_http_plan_job_dedupe_and_cancel(monkeypatch):
import app.gateway.routers.enterprise_research as enterprise_router
tasks = MemoryEnterpriseResearchTaskStore()
jobs = MemoryEnterpriseResearchReportJobStore()
class NoopExecutor:
def __init__(self) -> None:
self.started: list[tuple[str, str]] = []
async def ensure_started(self, job_id: str, user_id: str) -> None:
self.started.append((job_id, user_id))
async def cancel(self, job_id: str, user_id: str):
job = await jobs.get_job(job_id, user_id)
if job is None:
return None
cancelled = await jobs.transition_job(
job_id, user_id, expected_statuses={"queued", "running"},
data={"status": "cancelled", "phase": "cancelled"},
)
await tasks.update_task(job["task_id"], user_id, {"active_report_job_id": None})
return cancelled
async def anonymous_actor(_request):
return None
monkeypatch.setattr(enterprise_router, "get_optional_user_from_request", anonymous_actor)
app = FastAPI()
app.include_router(enterprise_router.router)
app.state.enterprise_research_task_store = tasks
app.state.enterprise_research_report_job_store = jobs
app.state.enterprise_research_report_executor = NoopExecutor()
async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as client:
created = await client.post(
"/api/enterprise-research/tasks",
json={"subject": "企业风险", "queries": ["企业风险"], "knowledge_base_ids": []},
)
assert created.status_code == 201
task_id = created.json()["id"]
await tasks.update_task(
task_id, "default",
{
"status": "ready", "selected_source_ids": ["source-1"],
"sources": [{"chunk_id": "source-1", "title": "内部材料", "content": "已核验事实"}],
},
)
plan = await client.post(f"/api/enterprise-research/tasks/{task_id}/plan/draft")
assert plan.status_code == 200 and plan.json()["plan_markdown"]
saved = await client.put(
f"/api/enterprise-research/tasks/{task_id}/plan",
json={"plan_markdown": "# 企业风险报告", "selected_source_ids": ["source-1"]},
)
assert saved.status_code == 200
first = await client.post(
f"/api/enterprise-research/tasks/{task_id}/report-jobs",
json={"action": "initial", "style": "formal", "target_length": 2_000},
)
assert first.status_code == 201
duplicate = await client.post(
f"/api/enterprise-research/tasks/{task_id}/report-jobs",
json={"action": "initial"},
)
assert duplicate.status_code == 201 and duplicate.json()["id"] == first.json()["id"]
cancelled = await client.post(
f"/api/enterprise-research/tasks/{task_id}/report-jobs/{first.json()['id']}/cancel"
)
assert cancelled.status_code == 200 and cancelled.json()["status"] == "cancelled"
@pytest.mark.asyncio
async def test_executor_stream_commit_separates_reasoning_and_followup(monkeypatch):
import app.gateway.enterprise_research_report_executor as executor_module
tasks = MemoryEnterpriseResearchTaskStore()
jobs = MemoryEnterpriseResearchReportJobStore()
await _create(tasks, task_id="stream-task")
await tasks.update_task(
"stream-task", "u1",
{"plan_markdown": "# 研究计划", "report_markdown": "# 旧报告", "report_summary": "旧摘要"},
)
class FakeBackend:
def __init__(self, _config) -> None:
pass
async def stream_complete(self, *, messages, on_delta, on_reasoning, **_kwargs):
is_followup = "不要重写整篇报告" in messages[0]["content"]
text = "追问回答" if is_followup else "# 新报告\n正文 [资料:source-1]"
await on_reasoning("模型内部思考")
for delta in (text[:4], text[4:]):
await on_delta(delta)
return SimpleNamespace(text=text, model="fake-model")
monkeypatch.setattr(executor_module, "DeerFlowCompletionBackend", FakeBackend)
executor = executor_module.EnterpriseResearchReportExecutor(tasks, jobs)
await jobs.create_job(
{
"id": "initial-job", "task_id": "stream-task", "user_id": "u1", "plan_snapshot": "# 研究计划",
"sources": [{"chunk_id": "source-1", "content": "证据"}], "action": "initial",
}
)
await executor._run("initial-job", "u1")
completed = await jobs.get_job("initial-job", "u1")
task = await tasks.get_task("stream-task", "u1")
assert completed is not None and completed["status"] == "completed"
assert completed["report_markdown"] == "# 新报告\n正文 [资料:source-1]"
assert "模型内部思考" not in completed["report_markdown"]
assert task is not None and task["report_markdown"] == completed["report_markdown"]
await jobs.create_job(
{
"id": "followup-job", "task_id": "stream-task", "user_id": "u1", "plan_snapshot": "# 研究计划",
"sources": [{"chunk_id": "source-1", "content": "证据"}], "action": "followup",
"instruction": "结论是什么", "original_report": completed["report_markdown"],
}
)
await executor._run("followup-job", "u1")
followup = await jobs.get_job("followup-job", "u1")
unchanged = await tasks.get_task("stream-task", "u1")
assert followup is not None and followup["report_markdown"] == "追问回答"
assert unchanged is not None and unchanged["report_markdown"] == completed["report_markdown"]
@pytest.mark.asyncio
async def test_cross_process_cancel_cannot_be_overwritten_by_late_model_result(monkeypatch):
import app.gateway.enterprise_research_report_executor as executor_module
tasks = MemoryEnterpriseResearchTaskStore()
jobs = MemoryEnterpriseResearchReportJobStore()
await _create(tasks, task_id="cancel-task")
await tasks.update_task("cancel-task", "u1", {"report_markdown": "# 已保存报告"})
await jobs.create_job(
{"id": "cancel-job", "task_id": "cancel-task", "user_id": "u1", "plan_snapshot": "# 计划"}
)
started = asyncio.Event()
release = asyncio.Event()
class SlowBackend:
def __init__(self, _config) -> None:
pass
async def stream_complete(self, *, on_delta, **_kwargs):
started.set()
await release.wait()
await on_delta("# 不应提交的迟到结果")
return SimpleNamespace(text="# 不应提交的迟到结果", model="fake-model")
monkeypatch.setattr(executor_module, "DeerFlowCompletionBackend", SlowBackend)
writer = executor_module.EnterpriseResearchReportExecutor(tasks, jobs)
remote_gateway = executor_module.EnterpriseResearchReportExecutor(tasks, jobs)
running = asyncio.create_task(writer._run("cancel-job", "u1"))
await started.wait()
cancelled = await remote_gateway.cancel("cancel-job", "u1")
assert cancelled is not None and cancelled["status"] == "cancelled"
release.set()
with pytest.raises(asyncio.CancelledError):
await running
final_job = await jobs.get_job("cancel-job", "u1")
final_task = await tasks.get_task("cancel-task", "u1")
assert final_job is not None and final_job["status"] == "cancelled"
assert final_task is not None and final_task["report_markdown"] == "# 已保存报告"
@@ -6,6 +6,7 @@ from types import SimpleNamespace
import httpx
import pytest
from fastapi import FastAPI, HTTPException
from fastapi.responses import Response
from starlette.datastructures import Headers, QueryParams
from starlette.requests import Request
@@ -19,6 +20,8 @@ from deerflow.integrations.weknora.client import WeKnoraClient, WeKnoraError
from deerflow.persistence.llmwiki import MemoryLlmWikiStore
from deerflow.tools.builtins.llmwiki_search_tool import (
_sanitize_conversation_deposit_value as sanitize_tool_deposit_value,
)
from deerflow.tools.builtins.llmwiki_search_tool import (
selected_knowledge_base_ids,
)
@@ -31,11 +34,9 @@ def _request(
request_headers: dict[str, str] | None = None,
root_path: str = "",
) -> Request:
headers: list[tuple[bytes, bytes]] = [
(key.lower().encode(), value.encode()) for key, value in (request_headers or {}).items()
]
headers: list[tuple[bytes, bytes]] = [(key.lower().encode(), value.encode()) for key, value in (request_headers or {}).items()]
if cookies:
headers.append(("cookie".encode(), "; ".join(f"{key}={value}" for key, value in cookies.items()).encode()))
headers.append((b"cookie", "; ".join(f"{key}={value}" for key, value in cookies.items()).encode()))
return Request(
{
"type": "http",
@@ -173,9 +174,7 @@ def test_weknora_embed_cookie_bypasses_only_proxy_paths() -> None:
cookies = {"deerflow_weknora_embed": raw_cookie}
assert auth_middleware._is_weknora_embed_proxy_request(_request("/platform/knowledge-bases/kb", cookies=cookies))
assert auth_middleware._is_weknora_embed_proxy_request(
_request("/deerflow/platform/knowledge-bases/kb", cookies=cookies)
)
assert auth_middleware._is_weknora_embed_proxy_request(_request("/deerflow/platform/knowledge-bases/kb", cookies=cookies))
assert auth_middleware._is_weknora_embed_proxy_request(_request("/assets/index.js", cookies=cookies))
assert auth_middleware._is_weknora_embed_proxy_request(_request("/deerflow/assets/index.js", cookies=cookies))
for static_path in (
@@ -191,26 +190,14 @@ def test_weknora_embed_cookie_bypasses_only_proxy_paths() -> None:
assert auth_middleware._is_weknora_embed_proxy_request(request)
assert csrf_middleware.is_weknora_embed_proxy_request(request)
assert auth_middleware._is_weknora_embed_proxy_request(_request("/config.js", cookies=cookies))
assert auth_middleware._is_weknora_embed_proxy_request(
_request("/tdesign-icons/0.4.1/fonts/index.js", cookies=cookies)
)
assert auth_middleware._is_weknora_embed_proxy_request(_request("/tdesign-icons/0.4.1/fonts/index.js", cookies=cookies))
assert auth_middleware._is_weknora_embed_proxy_request(_request("/api/v1/knowledge-search", cookies=cookies))
assert auth_middleware._is_weknora_embed_proxy_request(
_request("/deerflow/api/v1/knowledge-search", cookies=cookies)
)
assert auth_middleware._is_weknora_embed_proxy_request(
_request("/api/llmwiki/weknora-embed/api/v1/auth/me", cookies=cookies)
)
assert auth_middleware._is_weknora_embed_proxy_request(
_request("/deerflow/api/llmwiki/weknora-embed/api/v1/auth/me", cookies=cookies)
)
assert auth_middleware._is_weknora_embed_proxy_request(_request("/deerflow/api/v1/knowledge-search", cookies=cookies))
assert auth_middleware._is_weknora_embed_proxy_request(_request("/api/llmwiki/weknora-embed/api/v1/auth/me", cookies=cookies))
assert auth_middleware._is_weknora_embed_proxy_request(_request("/deerflow/api/llmwiki/weknora-embed/api/v1/auth/me", cookies=cookies))
assert csrf_middleware.is_weknora_embed_proxy_request(_request("/api/v1/knowledge-search", cookies=cookies))
assert not auth_middleware._is_weknora_embed_proxy_request(
_request("/api/v1/knowledge-search", cookies={"deerflow_weknora_embed": "signed"})
)
assert not csrf_middleware.is_weknora_embed_proxy_request(
_request("/api/v1/knowledge-search", cookies={"deerflow_weknora_embed": "signed"})
)
assert not auth_middleware._is_weknora_embed_proxy_request(_request("/api/v1/knowledge-search", cookies={"deerflow_weknora_embed": "signed"}))
assert not csrf_middleware.is_weknora_embed_proxy_request(_request("/api/v1/knowledge-search", cookies={"deerflow_weknora_embed": "signed"}))
assert not auth_middleware._is_weknora_embed_proxy_request(_request("/api/v1/auth/me", cookies=cookies))
assert not auth_middleware._is_weknora_embed_proxy_request(_request("/api/models", cookies=cookies))
assert not auth_middleware._is_weknora_embed_proxy_request(_request("/platform/knowledge-bases/kb"))
@@ -227,6 +214,12 @@ async def test_weknora_session_endpoint_sets_cookie_and_returns_platform_path(mo
async def get_authorized(self, *_: object, **__: object) -> dict[str, str]:
return {"id": "local-kb", "weknora_id": "remote-kb"}
async def list_visible(self, *_: object, **__: object) -> list[dict[str, str]]:
return [
{"id": "local-kb", "weknora_id": "remote-kb"},
{"id": "public-kb", "weknora_id": "other-public-kb"},
]
monkeypatch.setattr(llmwiki_router, "_runtime_for_iframe_proxy", lambda _: object())
monkeypatch.setattr(llmwiki_router, "_authorized_mapping", authorized_mapping)
monkeypatch.setattr(llmwiki_router, "_store", lambda _: Store())
@@ -246,11 +239,7 @@ async def test_weknora_session_endpoint_sets_cookie_and_returns_platform_path(mo
assert "deerflow_weknora_embed=" in cookie
assert "Secure" in cookie
assert "SameSite=none" in cookie
set_cookie_headers = [
value.decode("latin-1")
for key, value in response.raw_headers
if key.lower() == b"set-cookie"
]
set_cookie_headers = [value.decode("latin-1") for key, value in response.raw_headers if key.lower() == b"set-cookie"]
assert any("Path=/" in value for value in set_cookie_headers)
assert any("Path=/deerflow" in value for value in set_cookie_headers)
raw = cookie.split("deerflow_weknora_embed=", 1)[1].split(";", 1)[0]
@@ -258,6 +247,7 @@ async def test_weknora_session_endpoint_sets_cookie_and_returns_platform_path(mo
assert ctx.mapping_id == "local-kb"
assert ctx.weknora_id == "remote-kb"
assert ctx.can_write is True
assert ctx.allowed_weknora_ids == ("remote-kb", "other-public-kb")
@pytest.mark.asyncio
@@ -271,6 +261,9 @@ async def test_weknora_session_endpoint_preserves_reverse_proxy_prefix(monkeypat
async def get_authorized(self, *_: object, **__: object) -> dict[str, str]:
return {"id": "local-kb", "weknora_id": "remote-kb"}
async def list_visible(self, *_: object, **__: object) -> list[dict[str, str]]:
return []
monkeypatch.setattr(llmwiki_router, "_runtime_for_iframe_proxy", lambda _: object())
monkeypatch.setattr(llmwiki_router, "_authorized_mapping", authorized_mapping)
monkeypatch.setattr(llmwiki_router, "_store", lambda _: Store())
@@ -301,6 +294,9 @@ async def test_weknora_session_endpoint_uses_backend_prefix_when_frontend_has_di
async def get_authorized(self, *_: object, **__: object) -> dict[str, str]:
return {"id": "local-kb", "weknora_id": "remote-kb"}
async def list_visible(self, *_: object, **__: object) -> list[dict[str, str]]:
return []
monkeypatch.setattr(llmwiki_router, "_runtime_for_iframe_proxy", lambda _: object())
monkeypatch.setattr(llmwiki_router, "_authorized_mapping", authorized_mapping)
monkeypatch.setattr(llmwiki_router, "_store", lambda _: Store())
@@ -1089,15 +1085,9 @@ def test_weknora_iframe_cookie_is_signed_and_short_lived() -> None:
def test_weknora_iframe_proxy_is_fallback_after_deerflow_api_routes() -> None:
assert _first_gateway_match("POST", "/api/v1/auth/login/username") == "/api/v1/auth/login/username"
assert _first_gateway_match("POST", "/api/v1/knowledge-search") == "/api/v1/{proxied_path:path}"
assert (
_first_gateway_match("GET", "/api/llmwiki/weknora-embed/api/v1/auth/me")
== "/api/llmwiki/weknora-embed/api/v1/{proxied_path:path}"
)
assert _first_gateway_match("GET", "/api/llmwiki/weknora-embed/api/v1/auth/me") == "/api/llmwiki/weknora-embed/api/v1/{proxied_path:path}"
assert _first_gateway_match("GET", "/platform/knowledge-bases/remote-kb") == "/platform/{proxied_path:path}"
assert (
_first_gateway_match("GET", "/deerflow/platform/knowledge-bases/remote-kb")
== "/deerflow/platform/{proxied_path:path}"
)
assert _first_gateway_match("GET", "/deerflow/platform/knowledge-bases/remote-kb") == "/deerflow/platform/{proxied_path:path}"
assert _first_gateway_match("GET", "/deerflow/assets/index.js") == "/deerflow/assets/{proxied_path:path}"
assert _first_gateway_match("GET", "/deerflow/js/index.js") == "/deerflow/{proxied_path:path}"
assert _first_gateway_match("GET", "/deerflow/css/index.css") == "/deerflow/{proxied_path:path}"
@@ -1177,21 +1167,13 @@ async def test_prefixed_weknora_proxy_serves_page_static_assets_and_api_without_
if path == "/platform/knowledge-bases/remote-kb":
return httpx.Response(
200,
text=(
'<html><head><script src="/assets/main.js"></script>'
'<link rel="stylesheet" href="css/app.css">'
'<script src="/config.js"></script></head><body></body></html>'
),
text=('<html><head><script src="/assets/main.js"></script><link rel="stylesheet" href="css/app.css"><script src="/config.js"></script></head><body></body></html>'),
headers={"content-type": "text/html; charset=utf-8"},
)
if path == "/assets/main.js":
return httpx.Response(
200,
text=(
'const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=['
'"assets/lazy.css","assets/lazy.js"])))=>i.map(i=>d[i]);'
'const chunk="/static/chunk.js",matcher=/platform\\//;fetch("/api/v1/auth/me")'
),
text=('const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/lazy.css","assets/lazy.js"])))=>i.map(i=>d[i]);const chunk="/static/chunk.js",matcher=/platform\\//;fetch("/api/v1/auth/me")'),
headers={"content-type": "application/javascript"},
)
if path == "/css/app.css":
@@ -1246,7 +1228,7 @@ async def test_prefixed_weknora_proxy_serves_page_static_assets_and_api_without_
assert '"deerflow/assets/lazy.css"' in script.text
assert '"deerflow/assets/lazy.js"' in script.text
assert '"/deerflow/assets/lazy.css"' not in script.text
assert 'matcher=/platform\\//' in script.text
assert "matcher=/platform\\//" in script.text
assert 'fetch("/deerflow/api/v1/auth/me")' in script.text
stylesheet = await client.get("/deerflow/css/app.css")
@@ -1280,6 +1262,7 @@ def test_weknora_iframe_hides_current_outer_sidebar_shell() -> None:
is_admin=False,
can_write=False,
exp=4_102_444_800,
allowed_weknora_ids=("remote-kb", "other-visible-kb"),
)
injection = llmwiki_router._weknora_embed_injection(
allowed_path="/platform/knowledge-bases/remote-kb",
@@ -1302,6 +1285,7 @@ def test_weknora_iframe_html_rewrites_public_prefix_paths() -> None:
is_admin=False,
can_write=False,
exp=4_102_444_800,
allowed_weknora_ids=("remote-kb", "other-visible-kb"),
)
html = b'<html><head><script src="/assets/index.js"></script></head><body>fetch("/api/v1/auth/me")</body></html>'
@@ -1318,9 +1302,12 @@ def test_weknora_iframe_html_rewrites_public_prefix_paths() -> None:
assert 'fetch("/deerflow/api/v1/auth/me")' in injected
assert '"apiPrefix":"/deerflow/api/llmwiki/weknora-embed"' in injected
assert '"allowedPath":"/deerflow/platform/knowledge-bases/remote-kb"' in injected
assert '"allowedWeKnoraIds":["remote-kb","other-visible-kb"]' in injected
assert ".breadcrumb-link.dropdown" not in injected
assert "reloadForKnowledgeBaseSwitch" in injected
def test_weknora_iframe_filters_kb_list_to_current_mapping() -> None:
def test_weknora_iframe_filters_kb_list_to_signed_visible_mappings() -> None:
from app.gateway.routers import llmwiki as llmwiki_router
ctx = llmwiki_router.WeKnoraEmbedContext(
@@ -1330,6 +1317,7 @@ def test_weknora_iframe_filters_kb_list_to_current_mapping() -> None:
is_admin=False,
can_write=False,
exp=4_102_444_800,
allowed_weknora_ids=("remote-kb", "other-visible-kb"),
)
response = httpx.Response(
200,
@@ -1337,6 +1325,7 @@ def test_weknora_iframe_filters_kb_list_to_current_mapping() -> None:
"success": True,
"data": [
{"id": "remote-kb", "name": "Allowed"},
{"id": "other-visible-kb", "name": "Also allowed"},
{"id": "other-kb", "name": "Blocked"},
],
},
@@ -1346,7 +1335,112 @@ def test_weknora_iframe_filters_kb_list_to_current_mapping() -> None:
assert filtered is not None
payload = json.loads(filtered)
assert payload["data"] == [{"id": "remote-kb", "name": "Allowed"}]
assert payload["data"] == [
{"id": "remote-kb", "name": "Allowed"},
{"id": "other-visible-kb", "name": "Also allowed"},
]
@pytest.mark.asyncio
async def test_weknora_iframe_switch_rechecks_selected_mapping_permissions(
monkeypatch: pytest.MonkeyPatch,
) -> None:
from app.gateway.routers import llmwiki as llmwiki_router
class Store:
async def get_by_weknora_id(self, weknora_id: str) -> dict[str, str] | None:
if weknora_id == "other-visible-kb":
return {"id": "public-kb", "weknora_id": weknora_id, "owner_user_id": "owner-b"}
return None
async def get_authorized(self, mapping_id: str, _: str, *, write: bool, **__: object) -> dict[str, str] | None:
if mapping_id != "public-kb":
return None
if write:
return None
return {"id": "public-kb", "weknora_id": "other-visible-kb", "owner_user_id": "owner-b"}
monkeypatch.setattr(llmwiki_router, "_store", lambda _: Store())
original = llmwiki_router.WeKnoraEmbedContext(
mapping_id="local-kb",
weknora_id="remote-kb",
user_id="user-a",
is_admin=False,
can_write=True,
exp=4_102_444_800,
allowed_weknora_ids=("remote-kb", "other-visible-kb"),
)
selected = await llmwiki_router._switch_embed_context(
_request("/platform/knowledge-bases/other-visible-kb"),
original,
"other-visible-kb",
)
assert selected.mapping_id == "public-kb"
assert selected.weknora_id == "other-visible-kb"
assert selected.can_write is False
@pytest.mark.asyncio
async def test_weknora_platform_proxy_reissues_cookie_for_native_kb_switch(
monkeypatch: pytest.MonkeyPatch,
) -> None:
from app.gateway.routers import llmwiki as llmwiki_router
current = llmwiki_router.WeKnoraEmbedContext(
mapping_id="local-kb",
weknora_id="remote-kb",
user_id="user-a",
is_admin=False,
can_write=False,
exp=4_102_444_800,
allowed_weknora_ids=("remote-kb", "other-visible-kb"),
)
selected = llmwiki_router.WeKnoraEmbedContext(
mapping_id="public-kb",
weknora_id="other-visible-kb",
user_id="user-a",
is_admin=False,
can_write=False,
exp=4_102_444_800,
allowed_weknora_ids=current.allowed_weknora_ids,
)
seen: dict[str, object] = {}
async def read_context(_: Request) -> object:
return current
async def switch_context(_: Request, ctx: object, weknora_id: str) -> object:
seen["current"] = ctx
seen["target"] = weknora_id
return selected
async def proxy_request(*_: object, **kwargs: object) -> Response:
seen.update(kwargs)
return Response("ok")
monkeypatch.setattr(llmwiki_router, "_read_embed_context", read_context)
monkeypatch.setattr(llmwiki_router, "_switch_embed_context", switch_context)
monkeypatch.setattr(
llmwiki_router,
"_runtime_for_iframe_proxy",
lambda _: SimpleNamespace(web_base_url="http://weknora-web"),
)
monkeypatch.setattr(llmwiki_router, "_proxy_weknora_request", proxy_request)
response = await llmwiki_router.proxy_weknora_platform_page(
_request("/platform/knowledge-bases/other-visible-kb", request_headers={"X-Forwarded-Proto": "https"}),
"knowledge-bases/other-visible-kb",
)
assert seen["current"] == current
assert seen["target"] == "other-visible-kb"
assert seen["upstream_path"] == "/platform/knowledge-bases/other-visible-kb"
raw_cookie = response.headers["set-cookie"].split("deerflow_weknora_embed=", 1)[1].split(";", 1)[0]
switched_context = llmwiki_router._verify_embed_cookie(raw_cookie)
assert switched_context.mapping_id == "public-kb"
assert switched_context.weknora_id == "other-visible-kb"
@pytest.mark.asyncio
@@ -1365,7 +1459,7 @@ async def test_conversation_deposit_iframe_sanitizes_legacy_brand(monkeypatch: p
def __init__(self, **_: object) -> None:
pass
async def __aenter__(self) -> "FakeAsyncClient":
async def __aenter__(self) -> FakeAsyncClient:
return self
async def __aexit__(self, *_: object) -> None:
@@ -115,6 +115,69 @@ async def test_delete_model_configuration_removes_matching_model_and_activates_c
]
@pytest.mark.asyncio
async def test_reorder_model_configurations_persists_a_complete_permutation(
tmp_path,
monkeypatch: pytest.MonkeyPatch,
) -> None:
config_path = tmp_path / "config.yaml"
config_path.write_text(
"""models:
- name: first
use: langchain_openai:ChatOpenAI
model: first
- name: second
use: langchain_openai:ChatOpenAI
model: second
""",
encoding="utf-8",
)
saved: dict[str, object] = {}
async def save_models(_request, raw_before: str, models: list[dict[str, object]]) -> list[dict[str, object]]:
saved["raw_before"] = raw_before
saved["models"] = models
return models
monkeypatch.setattr(router, "_resolve_config_path", lambda: config_path)
monkeypatch.setattr(router, "_save_models", save_models)
request = SimpleNamespace(state=SimpleNamespace(user=SimpleNamespace(system_role="admin")))
result = await router.reorder_model_configurations(
router.ModelOrderRequest(names=["second", "first"]),
request,
)
assert [item.name for item in result] == ["second", "first"]
assert [item["name"] for item in saved["models"]] == ["second", "first"]
@pytest.mark.asyncio
async def test_reorder_model_configurations_rejects_stale_or_partial_orders(
tmp_path,
monkeypatch: pytest.MonkeyPatch,
) -> None:
config_path = tmp_path / "config.yaml"
config_path.write_text(
"""models:
- name: first
use: langchain_openai:ChatOpenAI
model: first
- name: second
use: langchain_openai:ChatOpenAI
model: second
""",
encoding="utf-8",
)
monkeypatch.setattr(router, "_resolve_config_path", lambda: config_path)
request = SimpleNamespace(state=SimpleNamespace(user=SimpleNamespace(system_role="admin")))
with pytest.raises(Exception) as exc_info:
await router.reorder_model_configurations(router.ModelOrderRequest(names=["first"]), request)
assert getattr(exc_info.value, "status_code", None) == 409
@pytest.mark.asyncio
async def test_connection_test_uses_one_minimal_prompt_without_writing_config(
tmp_path,
@@ -0,0 +1,273 @@
"""Tests for PositionArtifactCapMiddleware."""
from __future__ import annotations
from types import SimpleNamespace
from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
from deerflow.agents.middlewares.position_artifact_cap_middleware import (
PositionArtifactCapMiddleware,
_reminder_for,
_successful_outputs_writes,
_successful_presents,
)
def _runtime(cap: int | None = 1) -> SimpleNamespace:
context: dict = {"thread_id": "t-pos"}
if cap is not None:
context["position_artifact_cap"] = cap
return SimpleNamespace(context=context, config={"configurable": dict(context)})
def _write_call(call_id: str, path: str = "/mnt/user-data/outputs/report.md") -> dict:
return {
"id": call_id,
"name": "write_file",
"args": {"path": path, "content": "# hello", "description": "deliver"},
}
def _present_call(call_id: str, path: str = "/mnt/user-data/outputs/report.md") -> dict:
return {
"id": call_id,
"name": "present_files",
"args": {"filepaths": [path]},
}
def test_successful_outputs_writes_counts_ok_in_current_turn_only() -> None:
messages = [
HumanMessage(content="上一轮"),
AIMessage(content="", tool_calls=[_write_call("old")]),
ToolMessage(content="OK", tool_call_id="old", name="write_file"),
HumanMessage(content="本轮请交付"),
AIMessage(content="", tool_calls=[_write_call("new")]),
ToolMessage(content="OK", tool_call_id="new", name="write_file"),
]
assert _successful_outputs_writes(messages, turn_start=3) == 1
def test_after_model_truncates_second_outputs_write_in_same_response() -> None:
mw = PositionArtifactCapMiddleware()
state = {
"messages": [
HumanMessage(content="请交付一份报告"),
AIMessage(
content="正在写入",
tool_calls=[
_write_call("w1"),
_write_call("w2", "/mnt/user-data/outputs/report-copy.md"),
_present_call("p1"),
],
),
]
}
update = mw.after_model(state, _runtime(1))
assert update is not None
tool_calls = update["messages"][0].tool_calls
assert [tc["id"] for tc in tool_calls] == ["w1", "p1"]
def test_after_model_strips_all_writes_once_cap_already_met() -> None:
mw = PositionArtifactCapMiddleware()
state = {
"messages": [
HumanMessage(content="请交付"),
AIMessage(content="", tool_calls=[_write_call("done")]),
ToolMessage(content="OK", tool_call_id="done", name="write_file"),
AIMessage(content="再写一份", tool_calls=[_write_call("again")]),
]
}
update = mw.after_model(state, _runtime(1))
assert update is not None
assert update["messages"][0].tool_calls == []
assert update.get("jump_to") == "end"
assert "产物上限" not in str(update["messages"][0].content)
assert "tool_calls" not in (update["messages"][0].additional_kwargs or {})
def test_after_model_noop_without_cap() -> None:
mw = PositionArtifactCapMiddleware()
state = {
"messages": [
HumanMessage(content="请交付"),
AIMessage(content="", tool_calls=[_write_call("w1"), _write_call("w2")]),
]
}
assert mw.after_model(state, _runtime(None)) is None
def test_wrap_tool_call_rejects_after_successful_delivery() -> None:
mw = PositionArtifactCapMiddleware()
state = {
"messages": [
HumanMessage(content="请交付"),
AIMessage(content="", tool_calls=[_write_call("done")]),
ToolMessage(content="OK", tool_call_id="done", name="write_file"),
]
}
request = SimpleNamespace(
tool_call=_write_call("again"),
runtime=_runtime(1),
state=state,
)
called = {"n": 0}
def handler(_request):
called["n"] += 1
return ToolMessage(content="OK", tool_call_id="again", name="write_file")
result = mw.wrap_tool_call(request, handler)
assert called["n"] == 0
assert isinstance(result, ToolMessage)
assert str(result.content).startswith("Error:")
def test_wrap_tool_call_allows_first_write() -> None:
mw = PositionArtifactCapMiddleware()
state = {"messages": [HumanMessage(content="请交付")]}
request = SimpleNamespace(
tool_call=_write_call("w1"),
runtime=_runtime(1),
state=state,
)
def handler(_request):
return ToolMessage(content="OK", tool_call_id="w1", name="write_file")
result = mw.wrap_tool_call(request, handler)
assert result.content == "OK"
def test_wrap_tool_call_rejects_parallel_second_write_in_same_batch() -> None:
"""Two write_file in one AIMessage can run concurrently; order in the list is the budget."""
mw = PositionArtifactCapMiddleware()
state = {
"messages": [
HumanMessage(content="请交付"),
AIMessage(content="", tool_calls=[_write_call("w1"), _write_call("w2")]),
]
}
first = SimpleNamespace(tool_call=_write_call("w1"), runtime=_runtime(1), state=state)
second = SimpleNamespace(tool_call=_write_call("w2"), runtime=_runtime(1), state=state)
def handler(request):
return ToolMessage(content="OK", tool_call_id=request.tool_call["id"], name="write_file")
assert mw.wrap_tool_call(first, handler).content == "OK"
rejected = mw.wrap_tool_call(second, handler)
assert str(rejected.content).startswith("Error:")
def test_after_model_clears_provider_tool_call_metadata() -> None:
mw = PositionArtifactCapMiddleware()
extra = {
"tool_calls": [
{"id": "w1", "type": "function", "function": {"name": "write_file"}},
{"id": "w2", "type": "function", "function": {"name": "write_file"}},
]
}
ai = AIMessage(content="写两份", tool_calls=[_write_call("w1"), _write_call("w2")])
ai.additional_kwargs = extra
state = {"messages": [HumanMessage(content="请交付"), ai]}
update = mw.after_model(state, _runtime(1))
assert update is not None
kept = update["messages"][0]
assert [tc["id"] for tc in kept.tool_calls] == ["w1"]
assert [item["id"] for item in kept.additional_kwargs.get("tool_calls", [])] == ["w1"]
def test_action_plan_style_cap_two_allows_second_write() -> None:
"""Action-plan is exempt in the UI (no flag); if a cap of 2 were set it must allow both."""
mw = PositionArtifactCapMiddleware()
state = {
"messages": [
HumanMessage(content="生成行动规划"),
AIMessage(content="", tool_calls=[_write_call("md", "/mnt/user-data/outputs/行动规划报告.md")]),
ToolMessage(content="OK", tool_call_id="md", name="write_file"),
AIMessage(
content="",
tool_calls=[_write_call("json", "/mnt/user-data/outputs/action-plan-subtasks.json")],
),
]
}
assert mw.after_model(state, _runtime(2)) is None
def test_after_model_truncates_second_present_files_in_same_response() -> None:
mw = PositionArtifactCapMiddleware()
state = {
"messages": [
HumanMessage(content="请交付"),
AIMessage(
content="",
tool_calls=[_write_call("w1"), _present_call("p1"), _present_call("p2")],
),
]
}
update = mw.after_model(state, _runtime(1))
assert update is not None
assert [tc["id"] for tc in update["messages"][0].tool_calls] == ["w1", "p1"]
def test_after_model_strips_second_present_after_first_succeeded() -> None:
"""Screenshot bug: write+present already done, weak model presents the same file again."""
mw = PositionArtifactCapMiddleware()
state = {
"messages": [
HumanMessage(content="请评估"),
AIMessage(content="", tool_calls=[_write_call("w1"), _present_call("p1")]),
ToolMessage(content="OK", tool_call_id="w1", name="write_file"),
ToolMessage(content="Successfully presented files", tool_call_id="p1", name="present_files"),
AIMessage(content="评估报告已交付", tool_calls=[_present_call("p2")]),
]
}
update = mw.after_model(state, _runtime(1))
assert update is not None
assert update["messages"][0].tool_calls == []
assert update.get("jump_to") == "end"
def test_wrap_tool_call_rejects_second_present_files() -> None:
mw = PositionArtifactCapMiddleware()
state = {
"messages": [
HumanMessage(content="请交付"),
AIMessage(content="", tool_calls=[_present_call("p1")]),
ToolMessage(content="Successfully presented files", tool_call_id="p1", name="present_files"),
]
}
request = SimpleNamespace(
tool_call=_present_call("p2"),
runtime=_runtime(1),
state=state,
)
called = {"n": 0}
def handler(_request):
called["n"] += 1
return ToolMessage(content="Successfully presented files", tool_call_id="p2", name="present_files")
result = mw.wrap_tool_call(request, handler)
assert called["n"] == 0
assert isinstance(result, ToolMessage)
assert "已经呈现" in str(result.content)
def test_reminder_asks_present_only_when_not_yet_presented() -> None:
assert "present_files" in (_reminder_for(writes_done=True, presents_done=False) or "")
done = _reminder_for(writes_done=True, presents_done=True) or ""
assert "已经 present_files" in done
assert "请立即 present_files" not in done
assert _reminder_for(writes_done=False, presents_done=False) is None
def test_successful_presents_counts_tool_result() -> None:
messages = [
HumanMessage(content="请交付"),
AIMessage(content="", tool_calls=[_present_call("p1")]),
ToolMessage(content="Successfully presented files", tool_call_id="p1", name="present_files"),
]
assert _successful_presents(messages, turn_start=0) == 1
@@ -206,14 +206,14 @@ def test_position_intent_prompt_keeps_the_original_step_one_guardrails():
assert phrase in prompt
def test_position_intent_clarification_waits_for_the_user_before_ready():
"""A same-run READY block must not consume the user-assistance pause."""
def test_fresh_intent_clarification_waits_for_the_user_before_ready():
"""A same-run READY block must not consume a fresh assistance pause."""
assert intent_router._clarification_blocks_ready(
intent_router.POSITION_INTENT_AGENT_ID,
{"name": "ask_clarification"},
is_fresh=True,
)
assert not intent_router._clarification_blocks_ready(
assert intent_router._clarification_blocks_ready(
intent_router.INTENT_AGENT_ID,
{"name": "ask_clarification"},
is_fresh=True,
@@ -0,0 +1,30 @@
"""Regression coverage for provider-safe transient context compression."""
from langchain_core.messages import AIMessage, HumanMessage, SystemMessage, ToolMessage
from deerflow.agents.middlewares.summarization_middleware import _ensure_latest_human_message
def test_compression_restores_latest_human_turn_when_only_tool_tail_remains():
user = HumanMessage(content="请分析这份材料", id="user-1")
source = [
user,
AIMessage(content="", id="ai-1"),
ToolMessage(content="检索结果", tool_call_id="call-1", id="tool-1"),
]
compressed = [SystemMessage(content="internal summary"), *source[1:]]
result = _ensure_latest_human_message(source, compressed)
assert result[0].type == "system"
assert result[1] is user
assert [message.type for message in result[2:]] == ["ai", "tool"]
def test_compression_does_not_duplicate_human_turn_already_in_tail():
user = HumanMessage(content="继续", id="user-1")
compressed = [SystemMessage(content="internal summary"), user]
result = _ensure_latest_human_message([user], compressed)
assert result == compressed