增强 Deep Research 可靠性,并接入 8BF 任务卡片与会商上下文。

修复 MySQL 读写分离下的持久化与 SSE 重连问题,报告完成前先落库;8BF 嵌入页支持 taskId 任务卡与独立意图 metadata;前端统一 createClientId 并更新 runtime 配置。

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
董宏凯andCursor committed 2026-08-17 18:16:05 +08:00
1 parent 47faa9bcdf
commit 771957429a
36 files changed
+2038 -300

No files matched your search

@@ -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,66 @@
"""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.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 == []
@@ -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,156 @@
"""Regression coverage for idempotent Deep Research job submission."""
from types import SimpleNamespace
import pytest
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):
return SimpleNamespace(
app=SimpleNamespace(
state=SimpleNamespace(
deep_research_session_store=sessions,
deep_research_job_store=jobs,
deep_research_dispatcher=dispatcher,
)
)
)
@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_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
@@ -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