代码合并

This commit is contained in:
董宏凯 committed 2026-09-08 09:40:31 +08:00
1 parent b0970de677
commit 8859c13cfb
26 files changed
+1707 -334

No files matched your search

@@ -25,6 +25,40 @@ class _DisabledCfg:
report_collaboration = ReportCollaborationConfig(enabled=False)
class _PlannerFakeLLM:
"""规划师假模型:需求确认回「读者」追问;工作流设计回单份定制方案。"""
_converse = (
'{"reply": "好的。先确认:这份报告的主要读者是谁?", "action": "clarify",'
'"questions": ["这份报告的主要读者是谁?"], "impact": ["读者影响研究线划分"],'
'"requirement": {"topic": "新能源汽车趋势报告"}}'
)
_ready = (
'{"reply": "明白了,读者为企业战略决策人员。我来设计工作流。", "action": "ready",'
'"assumptions": [], "requirement": {"topic": "新能源汽车趋势报告", "audience": "企业战略决策人员"}}'
)
_design = (
'{"reply": "已按需求设计定制工作流。", "strategy": "custom", "title": "定制方案",'
'"summary": "研究后写作", "rationale": "贴合需求", "estimated_duration_seconds": 900,'
'"estimated_cost_level": "low", "quality_gate_ids": ["cite_required"],'
'"nodes": ['
'{"slot_id": "research-1", "role_key": "researcher", "display_name": "研究员", "mission": "检索证据", "depends_on": [], "output_artifact_type": "EvidenceBundle"},'
'{"slot_id": "write-1", "role_key": "writer", "display_name": "撰写员", "mission": "成稿", "depends_on": ["research-1"], "output_artifact_type": "ReportSectionDraft"}]}'
)
async def ainvoke(self, messages):
from types import SimpleNamespace
prompt = str(messages[-1][1]) if messages else ""
if "请设计工作流" in prompt:
payload = self._design
elif "企业战略决策人员" in prompt or "读者" in prompt and "用户最新消息" in prompt:
payload = self._ready
else:
payload = self._converse
return SimpleNamespace(content=payload)
def _client(monkeypatch: pytest.MonkeyPatch, *, enabled: bool = True, user: str | None = "user_a") -> tuple[TestClient, MemoryReportCollaborationStore]:
monkeypatch.setattr(report_collaboration, "get_app_config", lambda: _Cfg() if enabled else _DisabledCfg())
app = FastAPI()
@@ -32,6 +66,7 @@ def _client(monkeypatch: pytest.MonkeyPatch, *, enabled: bool = True, user: str
inner = MemoryReportCollaborationStore()
store = PublishingReportCollaborationStore(inner, hub)
app.state.report_collaboration_store = store
app.state.report_collaboration_planner_llm = _PlannerFakeLLM
app.state.report_collaboration_live_hub = hub
app.state.report_collaboration_sse_settings = SseStreamSettings(
deadline_seconds=0.6,
@@ -126,14 +161,14 @@ def test_session_message_plan_run_http(monkeypatch: pytest.MonkeyPatch) -> None:
proposed_body = proposed.json()
assert proposed_body["session"]["status"] == "proposal_ready"
plans = proposed_body["plans"]
assert {item["strategy"] for item in plans} == {"balanced_review", "parallel_depth", "focused_fast"}
assert {item["strategy"] for item in plans} == {"custom"}
plan = next(item for item in plans if item.get("recommended"))
assert plan["validation"]["ok"] is True
assert all(node.get("output_artifact_type") and node.get("acceptance_criteria") for node in plan["nodes"])
listed = client.get(f"/api/report-collaboration/sessions/{session_id}/plans")
assert listed.status_code == 200
assert len(listed.json()["plans"]) == 3
assert len(listed.json()["plans"]) == 1
selected = client.post(
f"/api/report-collaboration/sessions/{session_id}/plans/{plan['id']}/select",
@@ -7,7 +7,7 @@ from types import SimpleNamespace
import pytest
from app.report_collaboration.agentscope_runtime.event_adapter import ConversationReplica, MemberStreamContext, SeqAllocator, make_emitter
from app.report_collaboration.agentscope_runtime.model_adapter import DeerFlowChatModelAdapter, ModelAdapterError, record_attempt_usage, redact_secrets
from app.report_collaboration.agentscope_runtime.model_adapter import DeerFlowChatModelAdapter, ModelAdapterError, estimate_tokens_for_text, record_attempt_usage, redact_secrets
from app.report_collaboration.agentscope_runtime.model_resolver import freeze_plan_models, resolve_role_model
from deerflow.config.app_config import AppConfig
from deerflow.config.model_config import ModelConfig
@@ -128,6 +128,33 @@ async def test_adapter_streams_text_tool_and_usage() -> None:
assert frozen.value.code == "MODEL_FROZEN"
@pytest.mark.asyncio
async def test_adapter_count_tokens_and_context_size_contract() -> None:
"""AgentScope compress_context 依赖 model.context_size 与 count_tokens(messages, tools)。"""
snapshot = resolve_role_model("researcher", app_config=_app())
adapter = DeerFlowChatModelAdapter(snapshot, app_config=_app())
assert isinstance(adapter.context_size, int) and adapter.context_size > 0
class _Msg:
def __init__(self, text: str) -> None:
self.content = text
def get_content_blocks(self):
return [{"type": "text", "text": self.content}]
agentscope_style = [_Msg("市场分析" * 20)]
tokens_msg = await adapter.count_tokens(agentscope_style, None)
dict_style = [{"role": "user", "content": "hello world"}]
tokens_dict = await adapter.count_tokens(dict_style, None)
tools = [{"name": "web_search", "parameters": {"type": "object"}}]
tokens_tools = await adapter.count_tokens(dict_style, tools)
assert tokens_msg > 0
assert tokens_dict == estimate_tokens_for_text("hello world")
assert tokens_tools > tokens_dict
assert await adapter.count_tokens([], None) == 0
@pytest.mark.asyncio
async def test_adapter_redacts_provider_errors_and_records_metrics() -> None:
snapshot = resolve_role_model("writer", app_config=_app())
@@ -0,0 +1,181 @@
"""P1-R 规划师智能体:真对话(文案由智能体产出直接落库)+ 工作流设计 + 降级路径。"""
from __future__ import annotations
from types import SimpleNamespace
import pytest
from app.report_collaboration.contracts.requirements import ReportRequirementSnapshot
from app.report_collaboration.planning.planner_agent import PlannerAgent
from app.report_collaboration.requirement.resolver import RequirementResolver
from deerflow.persistence.report_collaboration import MemoryReportCollaborationStore
class _FakeLLM:
def __init__(self, payload: str) -> None:
self._payload = payload
async def ainvoke(self, messages):
return SimpleNamespace(content=self._payload)
_TURN_CLARIFY = """```json
{"reply": "好的,智能家居是个不错的方向。为了让团队分工更准,我想先确认两点:这份报告主要给谁看?大概需要多长的篇幅?",
"action": "clarify",
"questions": ["这份报告主要给谁看?", "大概需要多长的篇幅?"],
"impact": ["读者决定研究线划分", "篇幅决定成员数量"],
"requirement": {"topic": "智能家居设备2026年市场分析", "required_angles": ["市场规模", "竞争格局", "技术趋势"]}}
```"""
_TURN_READY = """{"reply": "明白了:给公司管理层的战略规划参考,5000字左右,覆盖三个角度。我现在就可以为你们设计工作流了。",
"action": "ready", "assumptions": ["地域默认中国大陆"],
"requirement": {"topic": "智能家居设备2026年市场分析", "audience": "公司管理层", "required_angles": ["市场规模", "竞争格局", "技术趋势"], "length_target": "5000字"}}"""
_DESIGN_JSON = """{"reply": "我按三个角度设计了两条并行研究线汇写再审的链路,正好对齐管理层决策的阅读习惯。",
"strategy": "custom", "title": "三角度并行研究工作流", "summary": "三线并行 + 汇写 + 独立审稿",
"rationale": "需求明确三个角度,管理层需要可信结论", "estimated_duration_seconds": 1800,
"estimated_cost_level": "medium", "quality_gate_ids": ["cite_required", "independent_review"],
"nodes": [
{"slot_id": "research-scale", "role_key": "researcher", "display_name": "研究员", "angle": "市场规模",
"mission": "检索市场规模证据", "depends_on": [], "output_artifact_type": "EvidenceBundle", "suggested_tools": ["web_search"]},
{"slot_id": "research-comp", "role_key": "researcher", "display_name": "研究员", "angle": "竞争格局",
"mission": "检索竞争格局证据", "depends_on": [], "output_artifact_type": "EvidenceBundle"},
{"slot_id": "research-tech", "role_key": "researcher", "display_name": "研究员", "angle": "技术趋势",
"mission": "检索技术趋势证据", "depends_on": [], "output_artifact_type": "EvidenceBundle"},
{"slot_id": "write-main", "role_key": "writer", "display_name": "撰写员",
"mission": "汇总三线证据成稿", "depends_on": ["research-scale", "research-comp", "research-tech"], "output_artifact_type": "ReportSectionDraft"},
{"slot_id": "review-1", "role_key": "reviewer", "display_name": "审稿员",
"mission": "独立审稿", "depends_on": ["write-main"], "output_artifact_type": "ReviewDecision"}
]}"""
# ── converse:智能体对话 ───────────────────────────────────────────────────
@pytest.mark.asyncio
async def test_converse_returns_agent_reply_and_questions() -> None:
agent = PlannerAgent(_FakeLLM(_TURN_CLARIFY))
turn = await agent.converse(
user_text="帮我写一份智能家居设备2026年市场分析报告",
history=[],
previous_snapshot=None,
previous_revision=0,
clarification_round=0,
max_rounds=3,
)
assert turn is not None and turn.action == "clarify"
assert "为了让团队分工更准" in turn.reply
assert len(turn.questions) == 2
merged = agent.merge_requirement(turn, previous_snapshot=None, previous_revision=0)
assert merged.topic == "智能家居设备2026年市场分析"
assert merged.revision == 1
@pytest.mark.asyncio
async def test_converse_forced_ready_at_round_cap() -> None:
agent = PlannerAgent(_FakeLLM(_TURN_CLARIFY))
turn = await agent.converse(
user_text="再说说",
history=[],
previous_snapshot={"topic": "智能家居市场", "revision": 2},
previous_revision=2,
clarification_round=3,
max_rounds=3,
)
assert turn is not None and turn.action == "ready"
assert turn.assumptions
@pytest.mark.asyncio
async def test_converse_invalid_json_returns_none() -> None:
agent = PlannerAgent(_FakeLLM("我拒绝输出 JSON"))
assert (
await agent.converse(
user_text="写报告",
history=[],
previous_snapshot=None,
previous_revision=0,
clarification_round=0,
max_rounds=3,
)
is None
)
@pytest.mark.asyncio
async def test_resolver_persists_agent_reply_without_template_wrapper() -> None:
store = MemoryReportCollaborationStore()
session = await store.create_session(owner_id="u1", title="新会话", idempotency_key="ik1")
resolver = RequirementResolver(store, planner_llm_factory=lambda: _FakeLLM(_TURN_CLARIFY))
decision = await resolver.handle_user_message(
session["id"],
user_message={"message_id": "m1", "role": "human", "content": "帮我写一份智能家居设备2026年市场分析报告"},
idempotency_key="ik-m1",
)
assert decision is not None and decision.reply and "为了让团队分工更准" in decision.reply
messages = await store.list_messages(session["id"])
ai_messages = [item for item in messages if item["role"] == "ai"]
assert ai_messages, "agent reply message missing"
assert "为了让团队分工更准" in ai_messages[-1]["content"]
assert "收到您的报告需求" not in ai_messages[-1]["content"] # 模板文案不得出现
@pytest.mark.asyncio
async def test_resolver_raises_when_agent_output_invalid() -> None:
"""模型输出不合法 → 直接报错(无规则/模板兜底)。"""
from deerflow.persistence.report_collaboration import ReportCollaborationValidationError
store = MemoryReportCollaborationStore()
session = await store.create_session(owner_id="u1", title="新会话", idempotency_key="ik1")
resolver = RequirementResolver(store, planner_llm_factory=lambda: _FakeLLM("not json"))
with pytest.raises(ReportCollaborationValidationError) as exc:
await resolver.handle_user_message(
session["id"],
user_message={"message_id": "m1", "role": "human", "content": "帮我写一份智能家居设备2026年市场分析报告"},
idempotency_key="ik-m1",
)
assert exc.value.code == "PLANNER_UNAVAILABLE"
# ── design_workflow:工作流设计 ───────────────────────────────────────────
@pytest.mark.asyncio
async def test_design_workflow_returns_strategy_with_context_reply() -> None:
requirement = ReportRequirementSnapshot(
topic="智能家居设备2026年市场分析",
required_angles=["市场规模", "竞争格局", "技术趋势"],
revision=2,
)
history = [{"role": "human", "content": "给管理层看,覆盖三个角度"}]
designed = await PlannerAgent(_FakeLLM(_DESIGN_JSON)).design_workflow(
requirement=requirement, history=history
)
assert designed is not None
strategy, reply = designed
assert strategy.strategy == "custom"
assert {slot.demand.role_key for slot in strategy.slots} == {"researcher", "writer", "reviewer"}
assert "管理层" in reply or "设计" in reply
write = next(slot for slot in strategy.slots if slot.slot_id == "write-main")
assert set(write.depends_on) == {"research-scale", "research-comp", "research-tech"}
@pytest.mark.asyncio
async def test_design_workflow_rejects_bad_vocabulary_and_cycles() -> None:
requirement = ReportRequirementSnapshot(topic="测试", revision=1)
agent = PlannerAgent(_FakeLLM(_DESIGN_JSON))
bad_role = _DESIGN_JSON.replace('"role_key": "writer"', '"role_key": "project_manager"')
assert await PlannerAgent(_FakeLLM(bad_role)).design_workflow(requirement=requirement, history=[]) is None
cyclic = _DESIGN_JSON.replace(
'"depends_on": [], "output_artifact_type": "EvidenceBundle", "suggested_tools"',
'"depends_on": ["review-1"], "output_artifact_type": "EvidenceBundle", "suggested_tools"',
)
assert await PlannerAgent(_FakeLLM(cyclic)).design_workflow(requirement=requirement, history=[]) is None
bad_artifact = _DESIGN_JSON.replace('"output_artifact_type": "ReportSectionDraft"', '"output_artifact_type": "PDF"')
assert await PlannerAgent(_FakeLLM(bad_artifact)).design_workflow(requirement=requirement, history=[]) is None
_ = agent # 保持引用清晰
@@ -12,7 +12,7 @@ from app.report_collaboration.planning.selector import AgentSelector
from app.report_collaboration.planning.service import PlanProposalService
from app.report_collaboration.planning.validator import validate_assembled_plan
from deerflow.config.report_collaboration_config import ReportCollaborationConfig
from deerflow.persistence.report_collaboration import MemoryReportCollaborationStore
from deerflow.persistence.report_collaboration import MemoryReportCollaborationStore, ReportCollaborationValidationError
class _AgentStore:
@@ -135,6 +135,26 @@ def test_validator_rejects_unknown_agent_id() -> None:
asyncio.run(_run())
class _DesignFakeLLM:
"""规划师工作流设计假模型:返回单份合法定制方案。"""
_payload = (
'{"reply": "我按需求设计了两条研究线汇写再审的定制工作流。",'
'"strategy": "custom", "title": "定制方案", "summary": "两线并行汇写再审",'
'"rationale": "贴合需求", "estimated_duration_seconds": 1200,'
'"estimated_cost_level": "medium", "quality_gate_ids": ["cite_required"],'
'"nodes": ['
'{"slot_id": "research-a", "role_key": "researcher", "display_name": "研究员", "angle": "市场", "mission": "检索市场证据", "depends_on": [], "output_artifact_type": "EvidenceBundle"},'
'{"slot_id": "write-main", "role_key": "writer", "display_name": "撰写员", "mission": "成稿", "depends_on": ["research-a"], "output_artifact_type": "ReportSectionDraft"}'
']}'
)
async def ainvoke(self, messages):
from types import SimpleNamespace
return SimpleNamespace(content=self._payload)
@pytest.mark.asyncio
async def test_service_writes_plans_without_starting_a_run() -> None:
store = MemoryReportCollaborationStore()
@@ -146,15 +166,20 @@ async def test_service_writes_plans_without_starting_a_run() -> None:
status="clarifying",
)
command = await store.enqueue_plan_request(session["id"], idempotency_key="ik-plan", expected_revision=1)
saved = await PlanProposalService(store).fulfill(session["id"], user_id="u1", command_id=command["command_id"], idempotency_key="ik-plan")
assert len(saved) == 3
saved = await PlanProposalService(store, llm_factory=lambda: _DesignFakeLLM()).fulfill(
session["id"], user_id="u1", command_id=command["command_id"], idempotency_key="ik-plan"
)
assert len(saved) == 1 # 智能体生成单份定制方案
snapshot = await store.get_snapshot(session["id"])
assert snapshot["session"]["status"] == "proposal_ready"
assert snapshot["session"]["selected_plan_id"] is None
assert snapshot["run"] is None
assert {item["strategy"] for item in snapshot["plans"]} == {"balanced_review", "parallel_depth", "focused_fast"}
assert snapshot["plans"][0]["strategy"] == "custom"
assert all(item["requirement_revision"] == 1 for item in snapshot["plans"])
assert snapshot["session"]["active_run_id"] is None
ai = [item for item in snapshot["messages"] if item["role"] == "ai"][-1]
assert ai["metadata"]["plan_source"] == "planner_agent"
assert "定制工作流" in ai["content"]
selected = await store.select_plan(session["id"], saved[0]["id"], idempotency_key="ik-select", expected_revision=1)
after_select = await store.get_snapshot(session["id"])
@@ -163,6 +188,24 @@ async def test_service_writes_plans_without_starting_a_run() -> None:
assert after_select["session"]["active_run_id"] is None
@pytest.mark.asyncio
async def test_service_raises_when_planner_unavailable() -> None:
store = MemoryReportCollaborationStore()
session = await store.create_session(owner_id="u1", title="", idempotency_key="s1b")
await store.save_requirement_state(
session["id"],
requirement_json={"snapshot": _requirement().model_dump(), "clarifications": [], "assumptions": [], "clarification_round": 1, "ready_to_plan": True},
requirement_revision=1,
status="clarifying",
)
command = await store.enqueue_plan_request(session["id"], idempotency_key="ik-plan2", expected_revision=1)
with pytest.raises(ReportCollaborationValidationError) as exc:
await PlanProposalService(store, llm_factory=lambda: None).fulfill(
session["id"], user_id="u1", command_id=command["command_id"], idempotency_key="ik-plan2"
)
assert exc.value.code == "PLANNER_UNAVAILABLE"
def test_cycle_is_rejected() -> None:
cfg = ReportCollaborationConfig()
candidate_nodes_cycle = AssembledPlan.model_validate(
@@ -1,76 +1,35 @@
"""RC-BE-005: pre-plan intent router and requirement resolver."""
"""P1-R 需求确认:规划师智能体是唯一路径(无规则/模板兜底)。"""
from __future__ import annotations
from types import SimpleNamespace
import pytest
from app.report_collaboration.requirement.extractor import extract_topic, wants_direct_start
from app.report_collaboration.requirement.intent_router import route_pre_plan_turn
from app.report_collaboration.requirement.resolver import RequirementResolver
from deerflow.persistence.report_collaboration import MemoryReportCollaborationStore
from deerflow.persistence.report_collaboration import MemoryReportCollaborationStore, ReportCollaborationValidationError
def test_topic_only_asks_plan_affecting_gaps() -> None:
decision = route_pre_plan_turn(
"写一份新能源汽车主要品牌市场趋势分析报告",
previous_snapshot=None,
previous_revision=0,
clarification_round=0,
max_clarification_rounds=3,
)
assert decision.action == "clarify"
assert "新能源" in decision.requirement.topic
assert decision.requirement.revision == 1
assert len(decision.questions) >= 2
assert any("读者" in item for item in decision.questions)
assert any("角度" in item for item in decision.questions)
class _ScriptedLLM:
"""按顺序吐出预置 JSON 决策(模拟规划师智能体多轮)。"""
def __init__(self, payloads: list[str]) -> None:
self._payloads = list(payloads)
async def ainvoke(self, messages):
payload = self._payloads.pop(0) if self._payloads else self._payloads[0]
return SimpleNamespace(content=payload)
def test_direct_start_records_default_assumptions() -> None:
first = route_pre_plan_turn(
"撰写新能源汽车趋势报告,直接开始",
previous_snapshot=None,
previous_revision=0,
clarification_round=0,
max_clarification_rounds=3,
)
assert first.action == "ready"
assert first.used_defaults is True
assert first.requirement.audience == "企业战略决策人员"
assert "市场份额" in first.requirement.required_angles
assert first.assumptions
_CLARIFY = """{"reply": "新能源汽车趋势是个好题目。先确认两个关键点:这份报告主要给谁看?希望覆盖哪些角度?",
"action": "clarify", "questions": ["这份报告主要给谁看?", "希望覆盖哪些角度?"],
"impact": ["读者影响研究线", "角度影响成员分工"],
"requirement": {"topic": "新能源汽车趋势报告"}}"""
def test_direct_start_without_topic_still_asks_topic() -> None:
decision = route_pre_plan_turn(
"直接开始",
previous_snapshot=None,
previous_revision=0,
clarification_round=0,
max_clarification_rounds=3,
)
assert decision.action == "clarify"
assert any("主题" in item for item in decision.questions)
def test_clarification_cap_uses_explicit_assumptions() -> None:
first = route_pre_plan_turn(
"写一份行业报告",
previous_snapshot=None,
previous_revision=0,
clarification_round=0,
max_clarification_rounds=1,
)
assert first.action == "clarify"
capped = route_pre_plan_turn(
"先这样吧",
previous_snapshot=first.requirement.model_dump(),
previous_revision=first.requirement.revision,
clarification_round=1,
max_clarification_rounds=1,
)
assert capped.action == "ready"
assert capped.used_defaults is True
_READY = """{"reply": "清楚了:给投资机构,覆盖市场份额、价格策略和政策环境。我来为你们设计工作流。",
"action": "ready", "assumptions": ["时间范围默认近两年"],
"requirement": {"topic": "新能源汽车趋势报告", "audience": "投资机构", "required_angles": ["市场份额", "价格策略", "政策环境"]}}"""
def test_extract_helpers() -> None:
@@ -79,14 +38,15 @@ def test_extract_helpers() -> None:
@pytest.mark.asyncio
async def test_resolver_writes_clarification_without_planning() -> None:
async def test_resolver_clarify_round_persists_agent_reply_and_record() -> None:
store = MemoryReportCollaborationStore()
session = await store.create_session(owner_id="u1", title="", idempotency_key="s1")
user = await store.create_message(session["id"], role="human", content="写一份新能源汽车趋势报告", idempotency_key="m1")
resolver = RequirementResolver(store)
llm = _ScriptedLLM([_CLARIFY])
resolver = RequirementResolver(store, planner_llm_factory=lambda: llm)
decision = await resolver.handle_user_message(session["id"], user_message=user, idempotency_key="m1", max_clarification_rounds=3)
assert decision is not None
assert decision.action == "clarify"
assert decision is not None and decision.action == "clarify"
assert "先确认两个关键点" in (decision.reply or "")
snapshot = await store.get_snapshot(session["id"])
assert snapshot["session"]["status"] == "clarifying"
@@ -96,10 +56,14 @@ async def test_resolver_writes_clarification_without_planning() -> None:
assert len(ai) == 1
assert ai[0]["completed_at"]
assert ai[0]["name"] == "协调者"
# 智能体文案直接落库,模板开场不得出现
assert "先确认两个关键点" in ai[0]["content"]
assert "收到您的报告需求" not in ai[0]["content"]
record = await store.get_session_record(session["id"])
assert record["requirement_json"]["ready_to_plan"] is False
assert record["requirement_json"]["clarifications"][0]["resolved"] is False
# 幂等:同一消息重放不产生第二条 AI 回复
replay = await resolver.handle_user_message(session["id"], user_message=user, idempotency_key="m1", max_clarification_rounds=3)
assert replay is None
snapshot2 = await store.get_snapshot(session["id"])
@@ -107,52 +71,63 @@ async def test_resolver_writes_clarification_without_planning() -> None:
@pytest.mark.asyncio
async def test_resolver_ready_is_not_plan_ready() -> None:
async def test_resolver_ready_writes_requirement_metadata_for_summary_card() -> None:
store = MemoryReportCollaborationStore()
session = await store.create_session(owner_id="u1", title="", idempotency_key="s2")
user = await store.create_message(
session["id"],
role="human",
content="写一份新能源汽车趋势报告,面向战略决策层,必须覆盖市场、政策、海外和风险,直接开始",
idempotency_key="m2",
session["id"], role="human", content="写一份新能源汽车趋势报告,给投资机构看", idempotency_key="m2"
)
resolver = RequirementResolver(store)
llm = _ScriptedLLM([_READY])
resolver = RequirementResolver(store, planner_llm_factory=lambda: llm)
decision = await resolver.handle_user_message(session["id"], user_message=user, idempotency_key="m2")
assert decision is not None
assert decision.action == "ready"
assert decision is not None and decision.action == "ready"
snapshot = await store.get_snapshot(session["id"])
assert snapshot["session"]["status"] == "clarifying"
assert snapshot["plans"] == []
assert snapshot["plans"] == [] # ready ≠ 已生成方案
ai = [item for item in snapshot["messages"] if item["role"] == "ai"][-1]
assert ai["metadata"]["ready_to_plan"] is True
assert ai["metadata"]["requirement"]["audience"] == "投资机构"
assert "设计工作流" in ai["content"]
record = await store.get_session_record(session["id"])
assert record["requirement_json"]["ready_to_plan"] is True
assert all(item["resolved"] for item in record["requirement_json"]["clarifications"])
assert "不等于已经生成" in snapshot["messages"][-1]["content"]
@pytest.mark.asyncio
async def test_answer_merges_and_resolves_clarification() -> None:
async def test_resolver_answer_merges_fields_across_rounds() -> None:
store = MemoryReportCollaborationStore()
session = await store.create_session(owner_id="u1", title="", idempotency_key="s3")
first = await store.create_message(session["id"], role="human", content="写一份新能源汽车趋势报告", idempotency_key="m3a")
resolver = RequirementResolver(store)
llm = _ScriptedLLM([_CLARIFY, _READY])
resolver = RequirementResolver(store, planner_llm_factory=lambda: llm)
await resolver.handle_user_message(session["id"], user_message=first, idempotency_key="m3a")
second = await store.create_message(
session["id"],
role="human",
content="读者是投资机构,必须覆盖市场份额、价格策略和政策环境",
idempotency_key="m3b",
session["id"], role="human", content="读者是投资机构,必须覆盖市场份额、价格策略和政策环境", idempotency_key="m3b"
)
decision = await resolver.handle_user_message(session["id"], user_message=second, idempotency_key="m3b")
assert decision is not None
assert decision.action == "ready"
assert decision.used_defaults is False
assert decision.requirement.audience == "投资机构"
assert decision is not None and decision.action == "ready"
assert decision.requirement.revision == 2
assert decision.requirement.audience == "投资机构"
assert set(decision.requirement.required_angles) == {"市场份额", "价格策略", "政策环境"}
record = await store.get_session_record(session["id"])
assert record["requirement_revision"] == 2
assert all(item["resolved"] for item in record["requirement_json"]["clarifications"])
snapshot = await store.get_snapshot(session["id"])
assert snapshot["plans"] == []
assert snapshot["session"]["status"] == "clarifying"
@pytest.mark.asyncio
async def test_resolver_raises_planner_unavailable_without_fallback() -> None:
store = MemoryReportCollaborationStore()
session = await store.create_session(owner_id="u1", title="", idempotency_key="s4")
user = await store.create_message(session["id"], role="human", content="写报告", idempotency_key="m4")
# 工厂显式禁用(模型不可用)→ 直接报错,无规则兜底
disabled = RequirementResolver(store, planner_llm_factory=lambda: None)
with pytest.raises(ReportCollaborationValidationError) as exc:
await disabled.handle_user_message(session["id"], user_message=user, idempotency_key="m4")
assert exc.value.code == "PLANNER_UNAVAILABLE"
# 模型输出不合法 → 同样报错
broken = RequirementResolver(store, planner_llm_factory=lambda: _ScriptedLLM(["我说人话不行吗"]))
with pytest.raises(ReportCollaborationValidationError) as exc2:
await broken.handle_user_message(session["id"], user_message=user, idempotency_key="m4")
assert exc2.value.code == "PLANNER_UNAVAILABLE"
@@ -155,6 +155,89 @@ async def test_waves_researcher_before_writer_and_text_does_not_complete() -> No
assert phases[f"{run_id}-research-attempt1"] != phases[f"{run_id}-write-attempt1"]
@pytest.mark.asyncio
async def test_command_rework_cascades_downstream_and_reruns_in_order() -> None:
"""P0.3 指定重跑级联:重跑 research 后 write 被级联 superseded 并按依赖序重跑。"""
store = MemoryReportCollaborationStore()
run_id = await _boot(store)
kernel = ScriptedMemberKernel()
kernel.enqueue("research", TaskResult(kind="artifact_draft", artifact_type="EvidenceBundle", artifact_draft=_evidence()))
kernel.enqueue("write", TaskResult(kind="artifact_draft", artifact_type="ReportSectionDraft", artifact_draft=_draft()))
executor = WaveExecutor(store, kernel)
assert await executor.run_until_idle(run_id) == "completed"
ledger = TaskLedger(store)
changed = await ledger.apply_command_rework(
run_id,
command_id="cmd-cascade-1",
instruction="重新查,重点看价格战",
node_ids=["research"],
cascade_downstream=True,
)
assert set(changed) == {"research", "write"}
nodes = await store.list_node_runs(run_id)
by_node: dict[str, list[dict]] = {}
for item in nodes:
by_node.setdefault(item["node_id"], []).append(item)
research_attempts = {item["attempt"]: item["status"] for item in by_node["research"]}
write_attempts = {item["attempt"]: item["status"] for item in by_node["write"]}
assert research_attempts[1] == "superseded" and research_attempts[2] == "planned"
assert write_attempts[1] == "superseded" and write_attempts[2] == "planned"
events = [item for item in await store.list_events(run_id) if item["type"] == "node.status.changed"]
cascade_events = [item for item in events if (item.get("data") or {}).get("reason") == "downstream_cascade"]
assert cascade_events and cascade_events[0]["data"]["node_id"] == "write"
kernel2 = ScriptedMemberKernel()
kernel2.enqueue("research", TaskResult(kind="artifact_draft", artifact_type="EvidenceBundle", artifact_draft=_evidence("价格战证据")))
kernel2.enqueue("write", TaskResult(kind="artifact_draft", artifact_type="ReportSectionDraft", artifact_draft=_draft()))
executor2 = WaveExecutor(store, kernel2)
assert await executor2.run_until_idle(run_id) == "completed"
assert executor2.dispatched == ["research", "write"]
@pytest.mark.asyncio
async def test_exhausted_interrupted_node_fails_run_instead_of_zombie() -> None:
"""P0.2 僵尸 run 守卫:attempt 耗尽的 interrupted 节点应让 run 进入 failed。"""
store = MemoryReportCollaborationStore()
run_id = await _boot(store, _plan(max_attempts=2))
# 模拟两次崩溃被 recovery 打断后 attempt 耗尽:research attempt2 interrupted。
nodes = await store.list_node_runs(run_id)
research = next(item for item in nodes if item["node_id"] == "research")
research["attempt"] = 2
research["status"] = "interrupted"
research["error"] = "lease_reclaimed"
await store.save_node_run(research)
write = next(item for item in nodes if item["node_id"] == "write")
write["status"] = "planned"
executor = WaveExecutor(store, ScriptedMemberKernel())
status = await executor.run_until_idle(run_id)
assert status == "failed"
run = await store.get_run(run_id)
assert run["status"] == "failed"
events = [item for item in await store.list_events(run_id) if item["type"] == "run.status.changed"]
assert events and events[-1]["data"]["reason"] == "node_attempts_exhausted"
assert events[-1]["data"]["node_id"] == "research"
@pytest.mark.asyncio
async def test_interrupted_with_budget_left_keeps_run_alive() -> None:
"""未耗尽的 interrupted 节点仍留给 recovery 补开 attempt,不能提前 fail。"""
store = MemoryReportCollaborationStore()
run_id = await _boot(store, _plan(max_attempts=3))
nodes = await store.list_node_runs(run_id)
research = next(item for item in nodes if item["node_id"] == "research")
research["attempt"] = 1
research["status"] = "interrupted"
await store.save_node_run(research)
ledger = TaskLedger(store)
assert await ledger.refresh_run_terminal(run_id) != "failed"
@pytest.mark.asyncio
async def test_parallel_researchers_share_phase() -> None:
store = MemoryReportCollaborationStore()