代码提交

This commit is contained in:
董宏凯 committed 2026-08-15 12:51:58 +08:00
1 parent 500dab29ab
commit 70da7c5649
59 files changed
+12108 -148

No files matched your search

@@ -0,0 +1,40 @@
"""Deep-research session persistence.
Exposes a store factory + a process-level default-store singleton, mirroring
``roundtable_jobs``: harness-side graph nodes call ``get_default_store()``;
``app/gateway/deps.py`` registers it at startup.
"""
from __future__ import annotations
from deerflow.persistence.deep_research_sessions.model import DeepResearchSessionRow
from deerflow.persistence.deep_research_sessions.sql import DeepResearchSessionRepository
def make_deep_research_session_store(
session_factory,
) -> DeepResearchSessionRepository | None:
if session_factory is None:
return None
return DeepResearchSessionRepository(session_factory)
_default_store: DeepResearchSessionRepository | None = None
def register_default_store(store: DeepResearchSessionRepository | None) -> None:
global _default_store
_default_store = store
def get_default_store() -> DeepResearchSessionRepository | None:
return _default_store
__all__ = [
"DeepResearchSessionRepository",
"DeepResearchSessionRow",
"get_default_store",
"make_deep_research_session_store",
"register_default_store",
]
@@ -0,0 +1,62 @@
"""ORM model for deep-research sessions.
A *session* is one research topic owned by a user: it holds the frozen config
snapshot, the latest report/plan, and points at the hidden runtime thread that
owns the artifact files. Multiple *jobs* (runs) can execute against a session
(re-run with different settings, resume after human review), but at most one
job is active at a time (enforced by the jobs table's ``active_dedupe_key``).
Field design follows ``roundtable_drafts`` / ``ai_writing_sessions``:
big JSON/text columns use ``PortableLongText``; timestamps use ``BeijingDateTime``.
"""
from __future__ import annotations
from datetime import UTC, datetime
import sqlalchemy as sa
from sqlalchemy import Integer, String
from sqlalchemy.orm import Mapped, mapped_column
from deerflow.persistence.base import Base
from deerflow.persistence.types import BeijingDateTime, PortableLongText
class DeepResearchSessionRow(Base):
__tablename__ = "deep_research_sessions"
id: Mapped[str] = mapped_column(String(64), primary_key=True)
user_id: Mapped[str | None] = mapped_column(String(64), nullable=True, index=True)
title: Mapped[str] = mapped_column(String(256), nullable=False, default="")
query: Mapped[str] = mapped_column(PortableLongText, nullable=False, default="")
# Research mode (basic/detailed/deep/multi_agent/quick) — denormalised for list views.
mode: Mapped[str] = mapped_column(String(32), nullable=False, default="basic", index=True)
# Session status machine: draft / running / awaiting_input / completed / failed / cancelled.
status: Mapped[str] = mapped_column(String(32), nullable=False, default="draft", index=True)
# Frozen config at creation/start time (full DeepResearchConfig JSON).
config_snapshot: Mapped[str | None] = mapped_column(PortableLongText, nullable=True)
# The hidden runtime thread that owns the artifacts (metadata.thread_type=deep_research).
runtime_thread_id: Mapped[str | None] = mapped_column(String(64), nullable=True, unique=True)
# Latest research plan (JSON) — updated by the planner node.
plan_snapshot: Mapped[str | None] = mapped_column(PortableLongText, nullable=True)
# Latest report outputs.
report_markdown: Mapped[str | None] = mapped_column(PortableLongText, nullable=True)
report_html: Mapped[str | None] = mapped_column(PortableLongText, nullable=True)
# Denormalised counts for list views (avoid joining sources table).
source_count: Mapped[int] = mapped_column(Integer, nullable=False, default=0, server_default=sa.text("0"))
# Token/cost usage snapshot (JSON: {model: {prompt, completion, total}}).
usage_snapshot: Mapped[str | None] = mapped_column(PortableLongText, nullable=True)
# Current active job id (null when none running).
active_job_id: Mapped[str | None] = mapped_column(String(64), nullable=True)
# User-facing error summary on failure.
error: Mapped[str | None] = mapped_column(PortableLongText, nullable=True)
created_at: Mapped[datetime] = mapped_column(
BeijingDateTime(), nullable=False, default=lambda: datetime.now(UTC)
)
updated_at: Mapped[datetime] = mapped_column(
BeijingDateTime(),
nullable=False,
default=lambda: datetime.now(UTC),
onupdate=lambda: datetime.now(UTC),
)
@@ -0,0 +1,222 @@
"""SQLAlchemy repository for deep-research sessions.
Mirrors the ``roundtable_jobs`` / ``ai_writing_sessions`` repository conventions:
constructed with an ``async_sessionmaker``, methods are ``async``, open
``async with self._sf() as session:`` blocks, and return **plain dicts**.
JSON columns round-trip through ``json.dumps`` / ``json.loads``.
"""
from __future__ import annotations
import json
import logging
from datetime import UTC, datetime
from typing import Any
from sqlalchemy import delete, func, select, update
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
from deerflow.persistence.deep_research_sessions.model import DeepResearchSessionRow
from deerflow.runtime.user_context import AUTO, _AutoSentinel, resolve_user_id
logger = logging.getLogger(__name__)
# Only these states have a durable job that consumes a per-user research slot.
# A draft is just an unsent composer record; counting it here makes a few saved
# drafts permanently trigger the start-job 429 guard.
IN_FLIGHT_STATUSES = ("running", "awaiting_input")
TERMINAL_STATUSES = ("completed", "failed", "cancelled")
def _loads(value: Any) -> Any:
if not isinstance(value, str) or not value:
return None
try:
return json.loads(value)
except Exception:
return None
def _dumps(value: Any) -> str | None:
if value is None:
return None
return json.dumps(value, ensure_ascii=False)
class DeepResearchSessionRepository:
def __init__(self, session_factory: async_sessionmaker[AsyncSession]) -> None:
self._sf = session_factory
# ── row ↔ dict ──────────────────────────────────────────────────────────
@staticmethod
def _row_to_dict(row: DeepResearchSessionRow) -> dict[str, Any]:
d = row.to_dict()
# Deserialize JSON columns.
for k in ("config_snapshot", "plan_snapshot", "usage_snapshot"):
if k in d:
d[k] = _loads(d[k])
return d
# ── create ──────────────────────────────────────────────────────────────
async def create(
self,
*,
id: str,
user_id: str | _AutoSentinel = AUTO,
title: str = "",
query: str = "",
mode: str = "basic",
status: str = "draft",
config_snapshot: dict[str, Any] | None = None,
runtime_thread_id: str | None = None,
) -> dict[str, Any]:
resolved = resolve_user_id(user_id, method_name="DeepResearchSessionRepository.create")
async with self._sf() as session:
row = DeepResearchSessionRow(
id=id,
user_id=resolved,
title=title,
query=query,
mode=mode,
status=status,
config_snapshot=_dumps(config_snapshot),
runtime_thread_id=runtime_thread_id,
)
session.add(row)
await session.commit()
await session.refresh(row)
return self._row_to_dict(row)
# ── read ────────────────────────────────────────────────────────────────
async def get(self, session_id: str, *, user_id: str | _AutoSentinel = AUTO) -> dict[str, Any] | None:
resolved = resolve_user_id(user_id, method_name="DeepResearchSessionRepository.get")
async with self._sf() as session:
stmt = select(DeepResearchSessionRow).where(DeepResearchSessionRow.id == session_id)
if resolved is not None:
stmt = stmt.where(DeepResearchSessionRow.user_id == resolved)
row = (await session.execute(stmt)).scalar_one_or_none()
return self._row_to_dict(row) if row else None
async def list_by_user(
self,
*,
user_id: str | _AutoSentinel = AUTO,
status: str | None = None,
limit: int = 20,
offset: int = 0,
) -> list[dict[str, Any]]:
"""Paginated session list for the history panel (excludes heavy report text)."""
resolved = resolve_user_id(user_id, method_name="DeepResearchSessionRepository.list_by_user")
async with self._sf() as session:
stmt = select(DeepResearchSessionRow)
if resolved is not None:
stmt = stmt.where(DeepResearchSessionRow.user_id == resolved)
if status:
stmt = stmt.where(DeepResearchSessionRow.status == status)
stmt = stmt.order_by(DeepResearchSessionRow.updated_at.desc()).limit(limit).offset(offset)
rows = (await session.execute(stmt)).scalars().all()
# Strip heavy columns for list views.
out: list[dict[str, Any]] = []
for r in rows:
d = self._row_to_dict(r)
d.pop("report_markdown", None)
d.pop("report_html", None)
d.pop("config_snapshot", None)
d.pop("plan_snapshot", None)
d.pop("usage_snapshot", None)
d.pop("error", None)
out.append(d)
return out
async def count_by_user(
self, *, user_id: str | _AutoSentinel = AUTO, status: str | None = None
) -> int:
resolved = resolve_user_id(user_id, method_name="DeepResearchSessionRepository.count_by_user")
async with self._sf() as session:
stmt = select(func.count(DeepResearchSessionRow.id))
if resolved is not None:
stmt = stmt.where(DeepResearchSessionRow.user_id == resolved)
if status:
stmt = stmt.where(DeepResearchSessionRow.status == status)
return int((await session.execute(stmt)).scalar() or 0)
async def count_active_by_user(self, *, user_id: str | _AutoSentinel = AUTO) -> int:
"""Count sessions with an in-flight job for the per-user concurrency limit.
Draft sessions deliberately do not count: they have no job row and a
user may safely keep any number of unfinished research prompts.
"""
resolved = resolve_user_id(user_id, method_name="DeepResearchSessionRepository.count_active_by_user")
async with self._sf() as session:
stmt = (
select(func.count(DeepResearchSessionRow.id))
.where(DeepResearchSessionRow.user_id == resolved)
.where(DeepResearchSessionRow.status.in_(list(IN_FLIGHT_STATUSES)))
)
return int((await session.execute(stmt)).scalar() or 0)
# ── update ──────────────────────────────────────────────────────────────
async def update(
self,
session_id: str,
*,
user_id: str | _AutoSentinel = AUTO,
**fields: Any,
) -> dict[str, Any] | None:
"""Generic field update; JSON-valued fields are auto-serialized."""
resolved = resolve_user_id(user_id, method_name="DeepResearchSessionRepository.update")
# Serialize known JSON columns.
if "config_snapshot" in fields and fields["config_snapshot"] is not None:
fields["config_snapshot"] = _dumps(fields["config_snapshot"])
if "plan_snapshot" in fields and fields["plan_snapshot"] is not None:
fields["plan_snapshot"] = _dumps(fields["plan_snapshot"])
if "usage_snapshot" in fields and fields["usage_snapshot"] is not None:
fields["usage_snapshot"] = _dumps(fields["usage_snapshot"])
fields["updated_at"] = datetime.now(UTC)
async with self._sf() as session:
where = [DeepResearchSessionRow.id == session_id]
if resolved is not None:
where.append(DeepResearchSessionRow.user_id == resolved)
result = await session.execute(
update(DeepResearchSessionRow).where(*where).values(**fields)
)
if result.rowcount == 0:
return None
await session.commit()
row = (
await session.execute(
select(DeepResearchSessionRow).where(DeepResearchSessionRow.id == session_id)
)
).scalar_one_or_none()
return self._row_to_dict(row) if row else None
# ── delete ──────────────────────────────────────────────────────────────
async def delete(
self, session_id: str, *, user_id: str | _AutoSentinel = AUTO
) -> bool:
resolved = resolve_user_id(user_id, method_name="DeepResearchSessionRepository.delete")
async with self._sf() as session:
where = [DeepResearchSessionRow.id == session_id]
if resolved is not None:
where.append(DeepResearchSessionRow.user_id == resolved)
result = await session.execute(delete(DeepResearchSessionRow).where(*where))
await session.commit()
return result.rowcount > 0
async def get_runtime_thread_id(self, session_id: str) -> str | None:
"""Look up the hidden thread id (for artifact cleanup on delete)."""
async with self._sf() as session:
row = (
await session.execute(
select(DeepResearchSessionRow.runtime_thread_id).where(
DeepResearchSessionRow.id == session_id
)
)
).scalar_one_or_none()
return row