代码提交

This commit is contained in:
董宏凯 committed 2026-08-16 19:17:45 +08:00
1 parent 70da7c5649
commit 178572bc7f
79 files changed
+13456 -798

No files matched your search

@@ -6,7 +6,7 @@ import json
import logging
from typing import Any
from sqlalchemy import func, select
from sqlalchemy import func, select, update
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
from deerflow.persistence.deep_research_messages.model import DeepResearchMessageRow
@@ -92,6 +92,58 @@ class DeepResearchMessageRepository:
rows = (await session.execute(stmt)).scalars().all()
return [self._row_to_dict(r) for r in rows]
async def get(
self,
message_id: str,
*,
session_id: str,
user_id: str | _AutoSentinel = AUTO,
) -> dict[str, Any] | None:
"""Fetch one follow-up message inside its owner-scoped session."""
resolved = resolve_user_id(user_id, method_name="DeepResearchMessageRepository.get")
async with self._sf() as session:
stmt = select(DeepResearchMessageRow).where(
DeepResearchMessageRow.id == message_id,
DeepResearchMessageRow.session_id == session_id,
)
if resolved is not None:
stmt = stmt.where(DeepResearchMessageRow.user_id == resolved)
row = (await session.execute(stmt)).scalar_one_or_none()
return self._row_to_dict(row) if row is not None else None
async def update_usage_snapshot(
self,
message_id: str,
*,
session_id: str,
usage_snapshot: dict[str, Any] | None,
user_id: str | _AutoSentinel = AUTO,
) -> dict[str, Any] | None:
"""Update durable UI metadata without altering the message transcript."""
resolved = resolve_user_id(
user_id,
method_name="DeepResearchMessageRepository.update_usage_snapshot",
)
async with self._sf() as session:
where = [
DeepResearchMessageRow.id == message_id,
DeepResearchMessageRow.session_id == session_id,
]
if resolved is not None:
where.append(DeepResearchMessageRow.user_id == resolved)
result = await session.execute(
update(DeepResearchMessageRow)
.where(*where)
.values(usage_snapshot=_dumps(usage_snapshot))
)
if not result.rowcount:
await session.rollback()
return None
await session.commit()
stmt = select(DeepResearchMessageRow).where(*where)
row = (await session.execute(stmt)).scalar_one_or_none()
return self._row_to_dict(row) if row is not None else None
async def delete_by_session(self, session_id: str) -> int:
from sqlalchemy import delete
@@ -195,6 +195,50 @@ class DeepResearchSessionRepository:
).scalar_one_or_none()
return self._row_to_dict(row) if row else None
async def replace_report_if_unchanged(
self,
session_id: str,
*,
expected_report: str,
report_markdown: str,
user_id: str | _AutoSentinel = AUTO,
) -> dict[str, Any] | None:
"""Atomically replace a report only when its exact prior text still matches.
The caller may use a hash for user-facing diagnostics, but SQL compares
the text itself so another request cannot slip in between a Python-side
hash check and the update.
"""
resolved = resolve_user_id(
user_id,
method_name="DeepResearchSessionRepository.replace_report_if_unchanged",
)
async with self._sf() as session:
clauses = [
DeepResearchSessionRow.id == session_id,
DeepResearchSessionRow.report_markdown == expected_report,
]
if resolved is not None:
clauses.append(DeepResearchSessionRow.user_id == resolved)
result = await session.execute(
update(DeepResearchSessionRow)
.where(*clauses)
.values(
report_markdown=report_markdown,
report_html=None,
updated_at=datetime.now(UTC),
)
)
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(
@@ -0,0 +1,17 @@
"""Document rewrite version persistence factory."""
from deerflow.persistence.document_rewrite_versions.model import DocumentRewriteVersionRow
from deerflow.persistence.document_rewrite_versions.sql import DocumentRewriteVersionRepository
def make_document_rewrite_version_store(session_factory) -> DocumentRewriteVersionRepository | None:
if session_factory is None:
return None
return DocumentRewriteVersionRepository(session_factory)
__all__ = [
"DocumentRewriteVersionRepository",
"DocumentRewriteVersionRow",
"make_document_rewrite_version_store",
]
@@ -0,0 +1,34 @@
"""Persistent, undoable snapshots for whole-document AI rewrites."""
from __future__ import annotations
from datetime import UTC, datetime
from sqlalchemy import String
from sqlalchemy.orm import Mapped, mapped_column
from deerflow.persistence.base import Base
from deerflow.persistence.types import BeijingDateTime, PortableLongText
class DocumentRewriteVersionRow(Base):
"""The immutable pre-rewrite document retained for one safe undo action."""
__tablename__ = "document_rewrite_versions"
id: Mapped[str] = mapped_column(String(64), primary_key=True)
user_id: Mapped[str | None] = mapped_column(String(64), nullable=True, index=True)
# ``artifact`` uses ``source_id=thread_id`` and a virtual sandbox path;
# ``deep_research_report`` uses ``source_id=deep-research session id``.
source_type: Mapped[str] = mapped_column(String(32), nullable=False, index=True)
source_id: Mapped[str] = mapped_column(String(128), nullable=False, index=True)
source_path: Mapped[str | None] = mapped_column(String(1024), nullable=True)
original_content: Mapped[str] = mapped_column(PortableLongText, nullable=False)
original_hash: Mapped[str] = mapped_column(String(64), nullable=False)
committed_hash: Mapped[str] = mapped_column(String(64), nullable=False)
instruction: Mapped[str | None] = mapped_column(PortableLongText, nullable=True)
model_name: Mapped[str | None] = mapped_column(String(256), nullable=True)
reverted_at: Mapped[datetime | None] = mapped_column(BeijingDateTime(), nullable=True)
created_at: Mapped[datetime] = mapped_column(
BeijingDateTime(), nullable=False, default=lambda: datetime.now(UTC)
)
@@ -0,0 +1,145 @@
"""Repository for document-rewrite snapshots.
The caller performs the actual content compare-and-swap. This repository keeps
the retained original version owner-scoped and marks a snapshot consumed after a
successful undo, preventing an older undo from silently overwriting newer work.
"""
from __future__ import annotations
from datetime import UTC, datetime
from typing import Any
from sqlalchemy import delete, select, update
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
from deerflow.persistence.document_rewrite_versions.model import DocumentRewriteVersionRow
from deerflow.runtime.user_context import AUTO, _AutoSentinel, resolve_user_id
class DocumentRewriteVersionRepository:
def __init__(self, session_factory: async_sessionmaker[AsyncSession]) -> None:
self._sf = session_factory
@staticmethod
def _row_to_dict(row: DocumentRewriteVersionRow) -> dict[str, Any]:
return row.to_dict()
async def create(
self,
*,
id: str,
source_type: str,
source_id: str,
source_path: str | None,
original_content: str,
original_hash: str,
committed_hash: str,
instruction: str | None = None,
model_name: str | None = None,
user_id: str | _AutoSentinel = AUTO,
) -> dict[str, Any]:
resolved = resolve_user_id(user_id, method_name="DocumentRewriteVersionRepository.create")
async with self._sf() as session:
row = DocumentRewriteVersionRow(
id=id,
user_id=resolved,
source_type=source_type,
source_id=source_id,
source_path=source_path,
original_content=original_content,
original_hash=original_hash,
committed_hash=committed_hash,
instruction=instruction,
model_name=model_name,
)
session.add(row)
await session.commit()
await session.refresh(row)
return self._row_to_dict(row)
async def get(
self,
version_id: str,
*,
user_id: str | _AutoSentinel = AUTO,
source_type: str | None = None,
) -> dict[str, Any] | None:
resolved = resolve_user_id(user_id, method_name="DocumentRewriteVersionRepository.get")
async with self._sf() as session:
clauses = [DocumentRewriteVersionRow.id == version_id]
if resolved is not None:
clauses.append(DocumentRewriteVersionRow.user_id == resolved)
if source_type:
clauses.append(DocumentRewriteVersionRow.source_type == source_type)
row = (await session.execute(select(DocumentRewriteVersionRow).where(*clauses))).scalar_one_or_none()
return self._row_to_dict(row) if row else None
async def mark_reverted(
self,
version_id: str,
*,
user_id: str | _AutoSentinel = AUTO,
) -> bool:
resolved = resolve_user_id(user_id, method_name="DocumentRewriteVersionRepository.mark_reverted")
async with self._sf() as session:
clauses = [
DocumentRewriteVersionRow.id == version_id,
DocumentRewriteVersionRow.reverted_at.is_(None),
]
if resolved is not None:
clauses.append(DocumentRewriteVersionRow.user_id == resolved)
result = await session.execute(
update(DocumentRewriteVersionRow)
.where(*clauses)
.values(reverted_at=datetime.now(UTC))
)
await session.commit()
return result.rowcount > 0
async def prune_source(
self,
*,
source_type: str,
source_id: str,
source_path: str | None,
keep: int = 20,
user_id: str | _AutoSentinel = AUTO,
) -> int:
"""Retain the newest snapshots for one document without crossing owners.
Old rewrite snapshots contain complete document bodies, so this is both a
storage guardrail and an explicit product boundary: users can undo the
recent history, not retain an unbounded hidden copy of every document.
"""
if keep < 1:
raise ValueError("keep must be at least one")
resolved = resolve_user_id(user_id, method_name="DocumentRewriteVersionRepository.prune_source")
async with self._sf() as session:
clauses = [
DocumentRewriteVersionRow.source_type == source_type,
DocumentRewriteVersionRow.source_id == source_id,
DocumentRewriteVersionRow.source_path == source_path,
]
if resolved is not None:
clauses.append(DocumentRewriteVersionRow.user_id == resolved)
stale_ids = list(
(
await session.scalars(
select(DocumentRewriteVersionRow.id)
.where(*clauses)
.order_by(
DocumentRewriteVersionRow.created_at.desc(),
DocumentRewriteVersionRow.id.desc(),
)
.offset(keep)
)
).all()
)
if not stale_ids:
return 0
result = await session.execute(
delete(DocumentRewriteVersionRow).where(DocumentRewriteVersionRow.id.in_(stale_ids))
)
await session.commit()
return int(result.rowcount or 0)
@@ -0,0 +1,43 @@
"""Create durable undo snapshots for whole-document AI rewrites.
Revision ID: 20260816_01
Revises: 20260813_07
Create Date: 2026-08-16
"""
from __future__ import annotations
import sqlalchemy as sa
from alembic import op
revision = "20260816_01"
down_revision = "20260813_07"
branch_labels = None
depends_on = None
def upgrade() -> None:
bind = op.get_bind()
if sa.inspect(bind).has_table("document_rewrite_versions"):
return
op.create_table(
"document_rewrite_versions",
sa.Column("id", sa.String(length=64), primary_key=True),
sa.Column("user_id", sa.String(length=64), nullable=True, index=True),
sa.Column("source_type", sa.String(length=32), nullable=False, index=True),
sa.Column("source_id", sa.String(length=128), nullable=False, index=True),
sa.Column("source_path", sa.String(length=1024), nullable=True),
sa.Column("original_content", sa.Text(), nullable=False),
sa.Column("original_hash", sa.String(length=64), nullable=False),
sa.Column("committed_hash", sa.String(length=64), nullable=False),
sa.Column("instruction", sa.Text(), nullable=True),
sa.Column("model_name", sa.String(length=256), nullable=True),
sa.Column("reverted_at", sa.DateTime(timezone=True), nullable=True),
sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
)
def downgrade() -> None:
bind = op.get_bind()
if sa.inspect(bind).has_table("document_rewrite_versions"):
op.drop_table("document_rewrite_versions")
@@ -43,6 +43,7 @@ from deerflow.persistence.deep_research_jobs.model import DeepResearchJobRow
from deerflow.persistence.deep_research_messages.model import DeepResearchMessageRow
from deerflow.persistence.deep_research_sessions.model import DeepResearchSessionRow
from deerflow.persistence.deep_research_sources.model import DeepResearchSourceRow
from deerflow.persistence.document_rewrite_versions.model import DocumentRewriteVersionRow
from deerflow.persistence.embed_sessions.model import EmbedSessionRow
from deerflow.persistence.feedback.model import FeedbackRow
from deerflow.persistence.intent_turns.model import IntentTurnRow
@@ -62,8 +63,8 @@ from deerflow.persistence.position_roundtable.model import (
from deerflow.persistence.positions.model import PositionRow, PositionTagBindingRow
from deerflow.persistence.recommended_questions.model import RecommendedQuestionRow
from deerflow.persistence.research_templates.model import ResearchTemplateRow
from deerflow.persistence.roundtable_chains.model import RoundtableChainRow
from deerflow.persistence.roundtable_artifact_submissions.model import RoundtableArtifactSubmissionRow
from deerflow.persistence.roundtable_chains.model import RoundtableChainRow
from deerflow.persistence.roundtable_diagnostics.model import RoundtableDiagnosticRow
from deerflow.persistence.roundtable_draft_shares.model import RoundtableDraftShareRow
from deerflow.persistence.roundtable_drafts.model import (
@@ -103,6 +104,7 @@ __all__ = [
"BusinessMappingRow",
"ConcurrencySampleRow",
"DashboardSessionRow",
"DocumentRewriteVersionRow",
"DeepResearchEventRow",
"DeepResearchJobRow",
"DeepResearchMessageRow",