sync update from LAN repo (source master-nj @ 067eb808)
This commit is contained in:
1 parent
1244fb1f2f
commit
1d5dd8fc90
182 files changed
+18973
-769
No files matched your search
+197
@@ -0,0 +1,197 @@
|
||||
"""User-owned analysis projects and immutable project/thread bindings."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from copy import deepcopy
|
||||
from datetime import UTC, datetime
|
||||
from uuid import uuid4
|
||||
|
||||
from sqlalchemy import ForeignKey, String, Text, delete, select
|
||||
from sqlalchemy.orm import Mapped, mapped_column
|
||||
|
||||
from deerflow.persistence.base import Base
|
||||
from deerflow.persistence.types import BeijingDateTime, PortableJSON
|
||||
|
||||
MODES = frozenset({"qa", "strategy", "solution"})
|
||||
CONFIG_FIELDS = frozenset({"agent_id", "report_config", "strategy_config"})
|
||||
EDITABLE_FIELDS = frozenset({"name", "background", "knowledge_base_ids", "assistant_knowledge_base_ids"}) | CONFIG_FIELDS
|
||||
|
||||
|
||||
class AnalysisProjectConfigRow(Base):
|
||||
"""Additive table: upgrades do not alter existing project/thread tables."""
|
||||
|
||||
__tablename__ = "analysis_project_configs"
|
||||
key: Mapped[str] = mapped_column(String(80), primary_key=True)
|
||||
config: Mapped[dict] = mapped_column(PortableJSON(), default=dict)
|
||||
|
||||
|
||||
class AnalysisProjectRow(Base):
|
||||
__tablename__ = "analysis_projects"
|
||||
|
||||
id: Mapped[str] = mapped_column(String(36), primary_key=True)
|
||||
user_id: Mapped[str] = mapped_column(String(255), index=True)
|
||||
name: Mapped[str] = mapped_column(String(160))
|
||||
mode: Mapped[str] = mapped_column(String(16))
|
||||
background: Mapped[str] = mapped_column(Text, default="")
|
||||
knowledge_base_ids: Mapped[list] = mapped_column(PortableJSON(), default=list)
|
||||
assistant_knowledge_base_ids: Mapped[list] = mapped_column(PortableJSON(), default=list)
|
||||
created_at: Mapped[datetime] = mapped_column(BeijingDateTime())
|
||||
updated_at: Mapped[datetime] = mapped_column(BeijingDateTime())
|
||||
|
||||
|
||||
class AnalysisProjectThreadRow(Base):
|
||||
__tablename__ = "analysis_project_threads"
|
||||
|
||||
thread_id: Mapped[str] = mapped_column(String(64), primary_key=True)
|
||||
project_id: Mapped[str] = mapped_column(ForeignKey("analysis_projects.id"), index=True)
|
||||
created_at: Mapped[datetime] = mapped_column(BeijingDateTime())
|
||||
|
||||
|
||||
def _dict(row):
|
||||
data = row.to_dict()
|
||||
for key in ("created_at", "updated_at"):
|
||||
if isinstance(data.get(key), datetime):
|
||||
data[key] = data[key].isoformat()
|
||||
return deepcopy(data)
|
||||
|
||||
|
||||
class AnalysisProjectStore:
|
||||
"""SQL in persistent deployments; isolated in-memory fallback for memory mode.
|
||||
|
||||
Every public project operation requires an explicit owner. The unscoped
|
||||
thread lookup is only for the Gateway's ownership and run-policy checks.
|
||||
Mode has no update path, and bindings are separate from client-editable metadata.
|
||||
"""
|
||||
|
||||
def __init__(self, session_factory=None):
|
||||
self._sf = session_factory
|
||||
self._projects: dict[str, dict] = {}
|
||||
self._threads: dict[str, dict] = {}
|
||||
self._configs: dict[str, dict] = {}
|
||||
|
||||
async def config_for(self, key: str) -> dict:
|
||||
if not self._sf:
|
||||
return deepcopy(self._configs.get(key, {}))
|
||||
async with self._sf() as session:
|
||||
row = await session.get(AnalysisProjectConfigRow, key)
|
||||
return deepcopy(row.config) if row else {}
|
||||
|
||||
async def _enrich(self, project: dict | None) -> dict | None:
|
||||
if project is None:
|
||||
return None
|
||||
return {
|
||||
**project,
|
||||
"agent_id": None,
|
||||
"report_config": {},
|
||||
"strategy_config": {},
|
||||
**await self.config_for(f"project:{project['id']}"),
|
||||
}
|
||||
|
||||
async def create(self, user_id: str, *, mode: str, **fields) -> dict:
|
||||
if mode not in MODES or set(fields) - EDITABLE_FIELDS:
|
||||
raise ValueError("Invalid project fields")
|
||||
now = datetime.now(UTC)
|
||||
row = AnalysisProjectRow(
|
||||
id=str(uuid4()),
|
||||
user_id=user_id,
|
||||
mode=mode,
|
||||
name=fields["name"],
|
||||
background=fields.get("background", ""),
|
||||
knowledge_base_ids=list(fields.get("knowledge_base_ids", [])),
|
||||
assistant_knowledge_base_ids=list(fields.get("assistant_knowledge_base_ids", [])),
|
||||
created_at=now,
|
||||
updated_at=now,
|
||||
)
|
||||
if self._sf:
|
||||
async with self._sf() as session:
|
||||
session.add(row)
|
||||
session.add(AnalysisProjectConfigRow(key=f"project:{row.id}", config={key: deepcopy(fields[key]) for key in CONFIG_FIELDS if key in fields}))
|
||||
await session.commit()
|
||||
else:
|
||||
self._projects[row.id] = _dict(row)
|
||||
self._configs[f"project:{row.id}"] = {key: deepcopy(fields[key]) for key in CONFIG_FIELDS if key in fields}
|
||||
return await self._enrich(_dict(row))
|
||||
|
||||
async def list(self, user_id: str) -> list[dict]:
|
||||
if not self._sf:
|
||||
return [await self._enrich(deepcopy(p)) for p in sorted(self._projects.values(), key=lambda p: p["updated_at"], reverse=True) if p["user_id"] == user_id]
|
||||
async with self._sf() as session:
|
||||
result = await session.execute(select(AnalysisProjectRow).where(AnalysisProjectRow.user_id == user_id).order_by(AnalysisProjectRow.updated_at.desc()))
|
||||
rows = [_dict(row) for row in result.scalars()]
|
||||
return [await self._enrich(row) for row in rows]
|
||||
|
||||
async def get(self, project_id: str, user_id: str) -> dict | None:
|
||||
if not self._sf:
|
||||
row = self._projects.get(project_id)
|
||||
return await self._enrich(deepcopy(row)) if row and row["user_id"] == user_id else None
|
||||
async with self._sf() as session:
|
||||
row = (await session.execute(select(AnalysisProjectRow).where(AnalysisProjectRow.id == project_id, AnalysisProjectRow.user_id == user_id))).scalar_one_or_none()
|
||||
data = _dict(row) if row else None
|
||||
return await self._enrich(data)
|
||||
|
||||
async def update(self, project_id: str, user_id: str, **fields) -> dict | None:
|
||||
if set(fields) - EDITABLE_FIELDS:
|
||||
raise ValueError("项目模式创建后不可更改")
|
||||
if not self._sf:
|
||||
row = self._projects.get(project_id)
|
||||
if not row or row["user_id"] != user_id:
|
||||
return None
|
||||
row.update({key: deepcopy(value) for key, value in fields.items() if key not in CONFIG_FIELDS}, updated_at=datetime.now(UTC).isoformat())
|
||||
self._configs.setdefault(f"project:{project_id}", {}).update({key: deepcopy(value) for key, value in fields.items() if key in CONFIG_FIELDS})
|
||||
return await self._enrich(deepcopy(row))
|
||||
async with self._sf() as session:
|
||||
row = (await session.execute(select(AnalysisProjectRow).where(AnalysisProjectRow.id == project_id, AnalysisProjectRow.user_id == user_id).with_for_update())).scalar_one_or_none()
|
||||
if row is None:
|
||||
return None
|
||||
for key, value in fields.items():
|
||||
if key not in CONFIG_FIELDS:
|
||||
setattr(row, key, deepcopy(value))
|
||||
options = await session.get(AnalysisProjectConfigRow, f"project:{project_id}")
|
||||
config = {**(options.config if options else {}), **{key: deepcopy(value) for key, value in fields.items() if key in CONFIG_FIELDS}}
|
||||
await session.merge(AnalysisProjectConfigRow(key=f"project:{project_id}", config=config))
|
||||
row.updated_at = datetime.now(UTC)
|
||||
await session.commit()
|
||||
data = _dict(row)
|
||||
return await self._enrich(data)
|
||||
|
||||
async def bind_thread(self, project_id: str, user_id: str, thread_id: str, *, agent_id: str | None = None) -> None:
|
||||
if await self.get(project_id, user_id) is None:
|
||||
raise ValueError("Project not found")
|
||||
row = AnalysisProjectThreadRow(thread_id=thread_id, project_id=project_id, created_at=datetime.now(UTC))
|
||||
if not self._sf:
|
||||
if thread_id in self._threads:
|
||||
raise ValueError("Thread already bound")
|
||||
self._threads[thread_id] = _dict(row)
|
||||
self._configs[f"thread:{thread_id}"] = {"agent_id": agent_id}
|
||||
return
|
||||
async with self._sf() as session:
|
||||
session.add(row)
|
||||
session.add(AnalysisProjectConfigRow(key=f"thread:{thread_id}", config={"agent_id": agent_id}))
|
||||
await session.commit()
|
||||
|
||||
async def project_for_thread(self, thread_id: str) -> dict | None:
|
||||
if not self._sf:
|
||||
binding = self._threads.get(thread_id)
|
||||
return await self._enrich(deepcopy(self._projects.get(binding["project_id"]))) if binding else None
|
||||
async with self._sf() as session:
|
||||
row = (await session.execute(select(AnalysisProjectRow).join(AnalysisProjectThreadRow).where(AnalysisProjectThreadRow.thread_id == thread_id))).scalar_one_or_none()
|
||||
data = _dict(row) if row else None
|
||||
return await self._enrich(data)
|
||||
|
||||
async def thread_ids(self, project_id: str, user_id: str) -> list[str]:
|
||||
if await self.get(project_id, user_id) is None:
|
||||
return []
|
||||
if not self._sf:
|
||||
return [key for key, value in reversed(list(self._threads.items())) if value["project_id"] == project_id]
|
||||
async with self._sf() as session:
|
||||
return list((await session.execute(select(AnalysisProjectThreadRow.thread_id).where(AnalysisProjectThreadRow.project_id == project_id).order_by(AnalysisProjectThreadRow.created_at.desc()))).scalars())
|
||||
|
||||
async def unbind_failed_creation(self, thread_id: str) -> None:
|
||||
if not self._sf:
|
||||
self._threads.pop(thread_id, None)
|
||||
self._configs.pop(f"thread:{thread_id}", None)
|
||||
return
|
||||
async with self._sf() as session:
|
||||
await session.execute(delete(AnalysisProjectThreadRow).where(AnalysisProjectThreadRow.thread_id == thread_id))
|
||||
await session.execute(delete(AnalysisProjectConfigRow).where(AnalysisProjectConfigRow.key == f"thread:{thread_id}"))
|
||||
await session.commit()
|
||||
+2
@@ -241,6 +241,8 @@ class AssistantKnowledgeRepository:
|
||||
) -> tuple[str, str]:
|
||||
metadata = package.get("source") or {}
|
||||
provider = str(metadata.get("provider") or metadata.get("type") or "").strip().casefold()
|
||||
if provider == "file" and metadata.get("digest"):
|
||||
return f"file:{metadata['digest']}", str(metadata.get("filename") or fallback_name)
|
||||
if provider == "weknora":
|
||||
source_key = str(
|
||||
metadata.get("knowledge_base_id")
|
||||
|
||||
+7
@@ -35,6 +35,7 @@ from deerflow.persistence.agents.model import (
|
||||
AgentRow,
|
||||
AgentSkillRow,
|
||||
)
|
||||
from deerflow.persistence.analysis_projects import AnalysisProjectConfigRow, AnalysisProjectRow, AnalysisProjectThreadRow
|
||||
from deerflow.persistence.assistant_knowledge.model import (
|
||||
AssistantKnowledgeBaseRow,
|
||||
AssistantKnowledgeEntityContributionRow,
|
||||
@@ -125,6 +126,7 @@ from deerflow.persistence.skill_knowledge.model import (
|
||||
SkillKnowledgeSyncJobRow,
|
||||
)
|
||||
from deerflow.persistence.skills.model import SkillDisplayAdapterRow, SkillFavoriteRow, SkillRow
|
||||
from deerflow.persistence.strategy_agent_roles.model import StrategyAgentRoleRow
|
||||
from deerflow.persistence.tags.model import TagAssignmentRow, TagRow
|
||||
from deerflow.persistence.task_buttons.model import TaskButtonRow
|
||||
from deerflow.persistence.task_reports.model import TaskReportRow
|
||||
@@ -149,6 +151,7 @@ from deerflow.persistence.workflow_runs.model import (
|
||||
from deerflow.persistence.workflows.model import WorkflowDefinitionRow, WorkflowVersionRow
|
||||
|
||||
__all__ = [
|
||||
"AnalysisProjectConfigRow",
|
||||
"FeedbackRow",
|
||||
"FixedQuestionRow",
|
||||
"AgentExtrasRow",
|
||||
@@ -159,6 +162,7 @@ __all__ = [
|
||||
"BusinessMappingRow",
|
||||
"AssistantKnowledgeBaseRow",
|
||||
"AssistantKnowledgeSourceRow",
|
||||
"AssistantKnowledgeVectorRow",
|
||||
"AssistantKnowledgeImportJobRow",
|
||||
"AssistantKnowledgeWikiPageRow",
|
||||
"AssistantKnowledgeWikiRevisionRow",
|
||||
@@ -254,9 +258,12 @@ __all__ = [
|
||||
"SkillKnowledgeSnapshotRow",
|
||||
"SkillKnowledgeSyncItemRow",
|
||||
"SkillKnowledgeSyncJobRow",
|
||||
"StrategyAgentRoleRow",
|
||||
"TagAssignmentRow",
|
||||
"TagRow",
|
||||
"TaskButtonRow",
|
||||
"AnalysisProjectRow",
|
||||
"AnalysisProjectThreadRow",
|
||||
"TaskCopTaskRow",
|
||||
"TaskReportRow",
|
||||
"EmbedSessionRow",
|
||||
|
||||
+33
-20
@@ -14,7 +14,7 @@ import json
|
||||
from datetime import UTC, datetime
|
||||
from typing import Any
|
||||
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy import select, update
|
||||
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
|
||||
|
||||
from deerflow.persistence.parallel_agent_tasks.model import ParallelAgentTaskRow
|
||||
@@ -59,12 +59,7 @@ class ParallelAgentTaskRepository:
|
||||
|
||||
async def list_tasks(self, user_id: str, *, limit: int = 200) -> list[dict[str, Any]]:
|
||||
"""列出当前用户的任务(轻量元信息,不含 messages,供历史列表)。"""
|
||||
stmt = (
|
||||
select(ParallelAgentTaskRow)
|
||||
.where(ParallelAgentTaskRow.user_id == user_id)
|
||||
.order_by(ParallelAgentTaskRow.updated_at.desc())
|
||||
.limit(limit)
|
||||
)
|
||||
stmt = select(ParallelAgentTaskRow).where(ParallelAgentTaskRow.user_id == user_id).order_by(ParallelAgentTaskRow.updated_at.desc()).limit(limit)
|
||||
async with self._sf() as session:
|
||||
result = await session.execute(stmt)
|
||||
return [self._to_dict(row, with_messages=False) for row in result.scalars()]
|
||||
@@ -103,22 +98,40 @@ class ParallelAgentTaskRepository:
|
||||
brief=_UNSET,
|
||||
agents=_UNSET,
|
||||
messages=_UNSET,
|
||||
expected_updated_at: datetime | str | None = None,
|
||||
) -> dict[str, Any] | None:
|
||||
async with self._sf() as session:
|
||||
row = await session.get(ParallelAgentTaskRow, task_id)
|
||||
if row is None or row.user_id != user_id:
|
||||
expected_revision = expected_updated_at
|
||||
if isinstance(expected_revision, str):
|
||||
try:
|
||||
expected_revision = datetime.fromisoformat(expected_revision.replace("Z", "+00:00"))
|
||||
except ValueError:
|
||||
return None
|
||||
|
||||
values: dict[str, Any] = {"updated_at": datetime.now(UTC)}
|
||||
if title is not _UNSET and title is not None:
|
||||
values["title"] = str(title).strip()
|
||||
if brief is not _UNSET:
|
||||
values["brief"] = brief or None
|
||||
if agents is not _UNSET:
|
||||
values["agents"] = _dumps(agents)
|
||||
if messages is not _UNSET:
|
||||
values["messages"] = _dumps(messages)
|
||||
|
||||
async with self._sf() as session:
|
||||
statement = update(ParallelAgentTaskRow).where(
|
||||
ParallelAgentTaskRow.id == task_id,
|
||||
ParallelAgentTaskRow.user_id == user_id,
|
||||
)
|
||||
if expected_revision is not None:
|
||||
statement = statement.where(ParallelAgentTaskRow.updated_at == expected_revision)
|
||||
result = await session.execute(statement.values(**values))
|
||||
if result.rowcount != 1:
|
||||
await session.rollback()
|
||||
return None
|
||||
if title is not _UNSET and title is not None:
|
||||
row.title = str(title).strip()
|
||||
if brief is not _UNSET:
|
||||
row.brief = brief or None
|
||||
if agents is not _UNSET:
|
||||
row.agents = _dumps(agents)
|
||||
if messages is not _UNSET:
|
||||
row.messages = _dumps(messages)
|
||||
row.updated_at = datetime.now(UTC)
|
||||
await session.commit()
|
||||
await session.refresh(row)
|
||||
row = await session.get(ParallelAgentTaskRow, task_id)
|
||||
if row is None:
|
||||
return None
|
||||
return self._to_dict(row)
|
||||
|
||||
async def delete_task(self, task_id: str, user_id: str) -> bool:
|
||||
|
||||
+24
@@ -0,0 +1,24 @@
|
||||
"""Global strategy-selection agent role registry."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from deerflow.persistence.strategy_agent_roles.base import StrategyAgentRoleStore
|
||||
from deerflow.persistence.strategy_agent_roles.memory import (
|
||||
MemoryStrategyAgentRoleStore,
|
||||
)
|
||||
from deerflow.persistence.strategy_agent_roles.model import StrategyAgentRoleRow
|
||||
from deerflow.persistence.strategy_agent_roles.sql import StrategyAgentRoleRepository
|
||||
|
||||
__all__ = [
|
||||
"MemoryStrategyAgentRoleStore",
|
||||
"StrategyAgentRoleRepository",
|
||||
"StrategyAgentRoleRow",
|
||||
"StrategyAgentRoleStore",
|
||||
"make_strategy_agent_role_store",
|
||||
]
|
||||
|
||||
|
||||
def make_strategy_agent_role_store(session_factory):
|
||||
if session_factory is None:
|
||||
return MemoryStrategyAgentRoleStore()
|
||||
return StrategyAgentRoleRepository(session_factory)
|
||||
+39
@@ -0,0 +1,39 @@
|
||||
"""Abstract store for the global strategy-selection agent registry."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from abc import ABC, abstractmethod
|
||||
from typing import Any
|
||||
|
||||
|
||||
class StrategyAgentRoleStore(ABC):
|
||||
@abstractmethod
|
||||
async def ensure_defaults(self, rows: list[dict[str, Any]]) -> int:
|
||||
"""Insert missing default rows without re-enabling disabled angles."""
|
||||
|
||||
@abstractmethod
|
||||
async def list_roles(self, *, include_disabled: bool) -> list[dict[str, Any]]:
|
||||
raise NotImplementedError
|
||||
|
||||
@abstractmethod
|
||||
async def get_role(self, agent_id: str) -> dict[str, Any] | None:
|
||||
raise NotImplementedError
|
||||
|
||||
@abstractmethod
|
||||
async def create_role(self, data: dict[str, Any]) -> dict[str, Any]:
|
||||
raise NotImplementedError
|
||||
|
||||
@abstractmethod
|
||||
async def update_role(
|
||||
self,
|
||||
agent_id: str,
|
||||
*,
|
||||
enabled: bool | None = None,
|
||||
sort_order: int | None = None,
|
||||
) -> dict[str, Any] | None:
|
||||
raise NotImplementedError
|
||||
|
||||
@abstractmethod
|
||||
async def delete_role(self, agent_id: str) -> bool:
|
||||
"""Hard-delete a registry row for create rollback only."""
|
||||
raise NotImplementedError
|
||||
+114
@@ -0,0 +1,114 @@
|
||||
"""In-memory strategy-agent registry used by memory persistence and tests."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
from datetime import UTC, datetime
|
||||
from typing import Any
|
||||
|
||||
from deerflow.persistence.strategy_agent_roles.base import StrategyAgentRoleStore
|
||||
|
||||
|
||||
def _now() -> str:
|
||||
return datetime.now(UTC).isoformat()
|
||||
|
||||
|
||||
def _copy(row: dict[str, Any]) -> dict[str, Any]:
|
||||
return dict(row)
|
||||
|
||||
|
||||
class MemoryStrategyAgentRoleStore(StrategyAgentRoleStore):
|
||||
def __init__(self) -> None:
|
||||
self._rows: dict[str, dict[str, Any]] = {}
|
||||
self._lock = asyncio.Lock()
|
||||
|
||||
async def ensure_defaults(self, rows: list[dict[str, Any]]) -> int:
|
||||
inserted = 0
|
||||
async with self._lock:
|
||||
for source in rows:
|
||||
agent_id = str(source["agent_id"])
|
||||
existing = self._rows.get(agent_id)
|
||||
if existing is not None:
|
||||
# Canonical fixed roles are executable infrastructure, not
|
||||
# administrator-managed lifecycle rows. Repair stale or
|
||||
# manually-corrupted metadata on every bootstrap. Angle
|
||||
# defaults deliberately retain their enabled/order state.
|
||||
if bool(source.get("fixed", False)):
|
||||
canonical = {
|
||||
"category": str(source["category"]),
|
||||
"fixed": True,
|
||||
"enabled": bool(source.get("enabled", True)),
|
||||
"sort_order": int(source.get("sort_order", 0)),
|
||||
}
|
||||
if any(existing.get(key) != value for key, value in canonical.items()):
|
||||
existing.update(canonical)
|
||||
existing["updated_at"] = _now()
|
||||
continue
|
||||
now = _now()
|
||||
self._rows[agent_id] = {
|
||||
"agent_id": agent_id,
|
||||
"category": str(source["category"]),
|
||||
"fixed": bool(source.get("fixed", False)),
|
||||
"enabled": bool(source.get("enabled", True)),
|
||||
"sort_order": int(source.get("sort_order", 0)),
|
||||
"created_at": now,
|
||||
"updated_at": now,
|
||||
}
|
||||
inserted += 1
|
||||
return inserted
|
||||
|
||||
async def list_roles(self, *, include_disabled: bool) -> list[dict[str, Any]]:
|
||||
async with self._lock:
|
||||
rows = [_copy(row) for row in self._rows.values() if include_disabled or bool(row.get("enabled"))]
|
||||
rows.sort(
|
||||
key=lambda row: (
|
||||
int(row.get("sort_order", 0)),
|
||||
str(row.get("agent_id", "")),
|
||||
)
|
||||
)
|
||||
return rows
|
||||
|
||||
async def get_role(self, agent_id: str) -> dict[str, Any] | None:
|
||||
async with self._lock:
|
||||
row = self._rows.get(agent_id)
|
||||
return _copy(row) if row is not None else None
|
||||
|
||||
async def create_role(self, data: dict[str, Any]) -> dict[str, Any]:
|
||||
agent_id = str(data["agent_id"])
|
||||
async with self._lock:
|
||||
if agent_id in self._rows:
|
||||
raise ValueError(f"Strategy agent role '{agent_id}' already exists")
|
||||
now = _now()
|
||||
row = {
|
||||
"agent_id": agent_id,
|
||||
"category": str(data["category"]),
|
||||
"fixed": bool(data.get("fixed", False)),
|
||||
"enabled": bool(data.get("enabled", True)),
|
||||
"sort_order": int(data.get("sort_order", 0)),
|
||||
"created_at": now,
|
||||
"updated_at": now,
|
||||
}
|
||||
self._rows[agent_id] = row
|
||||
return _copy(row)
|
||||
|
||||
async def update_role(
|
||||
self,
|
||||
agent_id: str,
|
||||
*,
|
||||
enabled: bool | None = None,
|
||||
sort_order: int | None = None,
|
||||
) -> dict[str, Any] | None:
|
||||
async with self._lock:
|
||||
row = self._rows.get(agent_id)
|
||||
if row is None:
|
||||
return None
|
||||
if enabled is not None:
|
||||
row["enabled"] = bool(enabled)
|
||||
if sort_order is not None:
|
||||
row["sort_order"] = int(sort_order)
|
||||
row["updated_at"] = _now()
|
||||
return _copy(row)
|
||||
|
||||
async def delete_role(self, agent_id: str) -> bool:
|
||||
async with self._lock:
|
||||
return self._rows.pop(agent_id, None) is not None
|
||||
+36
@@ -0,0 +1,36 @@
|
||||
"""Persistence model for the global strategy-selection agent registry."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from datetime import UTC, datetime
|
||||
|
||||
from sqlalchemy import Boolean, Integer, String
|
||||
from sqlalchemy.orm import Mapped, mapped_column
|
||||
|
||||
from deerflow.persistence.base import Base
|
||||
from deerflow.persistence.types import BeijingDateTime
|
||||
|
||||
|
||||
class StrategyAgentRoleRow(Base):
|
||||
"""Classify folder-backed agents used by the strategy-selection workflow.
|
||||
|
||||
The agent's model, skills and SOUL remain authoritative in its normal
|
||||
``config.yaml`` / ``SOUL.md`` files. This small global table owns only the
|
||||
workflow classification and lifecycle flags. Keeping a disabled row (and
|
||||
the underlying agent) protects saved projects that still reference it.
|
||||
"""
|
||||
|
||||
__tablename__ = "strategy_agent_roles"
|
||||
|
||||
agent_id: Mapped[str] = mapped_column(String(64), primary_key=True)
|
||||
category: Mapped[str] = mapped_column(String(16), nullable=False, index=True)
|
||||
fixed: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
|
||||
enabled: Mapped[bool] = mapped_column(Boolean, nullable=False, default=True, server_default="1", index=True)
|
||||
sort_order: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
|
||||
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),
|
||||
)
|
||||
+141
@@ -0,0 +1,141 @@
|
||||
"""SQLAlchemy-backed global strategy-selection agent registry."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from datetime import UTC, datetime
|
||||
from typing import Any
|
||||
|
||||
from sqlalchemy import delete, select
|
||||
from sqlalchemy.exc import IntegrityError
|
||||
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
|
||||
|
||||
from deerflow.persistence.strategy_agent_roles.base import StrategyAgentRoleStore
|
||||
from deerflow.persistence.strategy_agent_roles.model import StrategyAgentRoleRow
|
||||
|
||||
|
||||
def _to_dict(row: StrategyAgentRoleRow) -> dict[str, Any]:
|
||||
return {
|
||||
"agent_id": row.agent_id,
|
||||
"category": row.category,
|
||||
"fixed": row.fixed,
|
||||
"enabled": row.enabled,
|
||||
"sort_order": row.sort_order,
|
||||
"created_at": row.created_at.isoformat() if isinstance(row.created_at, datetime) else row.created_at,
|
||||
"updated_at": row.updated_at.isoformat() if isinstance(row.updated_at, datetime) else row.updated_at,
|
||||
}
|
||||
|
||||
|
||||
class StrategyAgentRoleRepository(StrategyAgentRoleStore):
|
||||
def __init__(self, session_factory: async_sessionmaker[AsyncSession]) -> None:
|
||||
self._sf = session_factory
|
||||
|
||||
async def ensure_defaults(self, rows: list[dict[str, Any]]) -> int:
|
||||
inserted = 0
|
||||
for source in rows:
|
||||
# Commit each of the small number of defaults independently. If
|
||||
# two workers race on one primary key, rolling that save back must
|
||||
# not also discard unrelated defaults inserted by this worker.
|
||||
async with self._sf() as session:
|
||||
agent_id = str(source["agent_id"])
|
||||
existing = await session.get(StrategyAgentRoleRow, agent_id)
|
||||
if existing is not None:
|
||||
if bool(source.get("fixed", False)):
|
||||
changed = False
|
||||
canonical = {
|
||||
"category": str(source["category"]),
|
||||
"fixed": True,
|
||||
"enabled": bool(source.get("enabled", True)),
|
||||
"sort_order": int(source.get("sort_order", 0)),
|
||||
}
|
||||
for key, value in canonical.items():
|
||||
if getattr(existing, key) != value:
|
||||
setattr(existing, key, value)
|
||||
changed = True
|
||||
if changed:
|
||||
existing.updated_at = datetime.now(UTC)
|
||||
await session.commit()
|
||||
continue
|
||||
now = datetime.now(UTC)
|
||||
session.add(
|
||||
StrategyAgentRoleRow(
|
||||
agent_id=agent_id,
|
||||
category=str(source["category"]),
|
||||
fixed=bool(source.get("fixed", False)),
|
||||
enabled=bool(source.get("enabled", True)),
|
||||
sort_order=int(source.get("sort_order", 0)),
|
||||
created_at=now,
|
||||
updated_at=now,
|
||||
)
|
||||
)
|
||||
try:
|
||||
await session.commit()
|
||||
except IntegrityError:
|
||||
# Another startup worker won this primary-key race.
|
||||
await session.rollback()
|
||||
continue
|
||||
inserted += 1
|
||||
return inserted
|
||||
|
||||
async def list_roles(self, *, include_disabled: bool) -> list[dict[str, Any]]:
|
||||
stmt = select(StrategyAgentRoleRow)
|
||||
if not include_disabled:
|
||||
stmt = stmt.where(StrategyAgentRoleRow.enabled.is_(True))
|
||||
stmt = stmt.order_by(
|
||||
StrategyAgentRoleRow.sort_order.asc(),
|
||||
StrategyAgentRoleRow.agent_id.asc(),
|
||||
)
|
||||
async with self._sf() as session:
|
||||
result = await session.execute(stmt)
|
||||
return [_to_dict(row) for row in result.scalars()]
|
||||
|
||||
async def get_role(self, agent_id: str) -> dict[str, Any] | None:
|
||||
async with self._sf() as session:
|
||||
row = await session.get(StrategyAgentRoleRow, agent_id)
|
||||
return _to_dict(row) if row is not None else None
|
||||
|
||||
async def create_role(self, data: dict[str, Any]) -> dict[str, Any]:
|
||||
now = datetime.now(UTC)
|
||||
row = StrategyAgentRoleRow(
|
||||
agent_id=str(data["agent_id"]),
|
||||
category=str(data["category"]),
|
||||
fixed=bool(data.get("fixed", False)),
|
||||
enabled=bool(data.get("enabled", True)),
|
||||
sort_order=int(data.get("sort_order", 0)),
|
||||
created_at=now,
|
||||
updated_at=now,
|
||||
)
|
||||
async with self._sf() as session:
|
||||
session.add(row)
|
||||
try:
|
||||
await session.commit()
|
||||
except IntegrityError as exc:
|
||||
await session.rollback()
|
||||
raise ValueError(f"Strategy agent role '{row.agent_id}' already exists") from exc
|
||||
await session.refresh(row)
|
||||
return _to_dict(row)
|
||||
|
||||
async def update_role(
|
||||
self,
|
||||
agent_id: str,
|
||||
*,
|
||||
enabled: bool | None = None,
|
||||
sort_order: int | None = None,
|
||||
) -> dict[str, Any] | None:
|
||||
async with self._sf() as session:
|
||||
row = await session.get(StrategyAgentRoleRow, agent_id)
|
||||
if row is None:
|
||||
return None
|
||||
if enabled is not None:
|
||||
row.enabled = bool(enabled)
|
||||
if sort_order is not None:
|
||||
row.sort_order = int(sort_order)
|
||||
row.updated_at = datetime.now(UTC)
|
||||
await session.commit()
|
||||
await session.refresh(row)
|
||||
return _to_dict(row)
|
||||
|
||||
async def delete_role(self, agent_id: str) -> bool:
|
||||
async with self._sf() as session:
|
||||
result = await session.execute(delete(StrategyAgentRoleRow).where(StrategyAgentRoleRow.agent_id == agent_id))
|
||||
await session.commit()
|
||||
return (result.rowcount or 0) > 0
|
||||
Reference in new issue
Block a user