feat: 完善策略优选项目工作流

This commit is contained in:
Administrator committed 2026-09-09 20:49:59 +08:00
1 parent a26fd32eba
commit 5d6627af50
45 files changed
+7235 -768

No files matched your search

@@ -211,6 +211,7 @@ class AppConfig(BaseModel):
cls._check_config_version(config_data, resolved_path)
config_data = cls.resolve_env_variables(config_data)
cls._resolve_relative_mount_paths(config_data, resolved_path.parent)
cls._apply_database_defaults(config_data)
# Load title config if present
@@ -272,6 +273,36 @@ class AppConfig(BaseModel):
result = cls.model_validate(config_data)
return result
@classmethod
def _resolve_relative_mount_paths(
cls,
config_data: dict[str, Any],
config_dir: Path,
) -> None:
"""Resolve portable sandbox mount paths beside ``config.yaml``.
Deployment copies frequently live at different absolute paths. A
relative ``sandbox.mounts[*].host_path`` therefore means "relative to
the config file", never relative to the process working directory.
Providers continue to receive absolute paths, which keeps both the
local path mapper and Docker bind mounts deterministic.
"""
sandbox = config_data.get("sandbox")
if not isinstance(sandbox, dict):
return
mounts = sandbox.get("mounts")
if not isinstance(mounts, list):
return
for mount in mounts:
if not isinstance(mount, dict):
continue
raw_host_path = mount.get("host_path")
if not isinstance(raw_host_path, str) or not raw_host_path.strip():
continue
host_path = Path(raw_host_path)
if not host_path.is_absolute():
mount["host_path"] = str((config_dir / host_path).resolve())
@classmethod
def _apply_database_defaults(cls, config_data: dict[str, Any]) -> None:
"""Apply config.yaml defaults for persistence when the section is absent."""
@@ -516,6 +516,16 @@ class LocalWikiEncoderSettings(BaseModel):
model_config = ConfigDict(extra="ignore")
class StrategyProjectSettings(BaseModel):
"""Global visibility controls for the strategy-project experience."""
taiwan_strait_demo_enabled: bool = Field(
default=False,
description="Whether Taiwan Strait demo entry points are visible in My Projects.",
)
model_config = ConfigDict(extra="ignore")
class SystemSettings(BaseModel):
"""Top-level system settings document."""
@@ -532,6 +542,7 @@ class SystemSettings(BaseModel):
concurrency_monitor: ConcurrencyMonitorSettings = Field(default_factory=ConcurrencyMonitorSettings)
model_concurrency: ModelConcurrencySettings = Field(default_factory=ModelConcurrencySettings)
local_wiki_encoder: LocalWikiEncoderSettings = Field(default_factory=LocalWikiEncoderSettings)
strategy_projects: StrategyProjectSettings = Field(default_factory=StrategyProjectSettings)
llmwiki: LlmWikiRuntimeOverride = Field(default_factory=LlmWikiRuntimeOverride)
skill_knowledge_auto_sync: SkillKnowledgeAutoSyncSettings = Field(default_factory=SkillKnowledgeAutoSyncSettings)
knowledge_base_product_version: Literal["v1", "v2"] = Field(
@@ -125,6 +125,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
@@ -254,6 +255,7 @@ __all__ = [
"SkillKnowledgeSnapshotRow",
"SkillKnowledgeSyncItemRow",
"SkillKnowledgeSyncJobRow",
"StrategyAgentRoleRow",
"TagAssignmentRow",
"TagRow",
"TaskButtonRow",
@@ -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:
@@ -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)
@@ -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
@@ -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
@@ -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),
)
@@ -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
@@ -21,9 +21,10 @@ class InlineThinkTagFilter:
_OPEN_TAG = "<think>"
_CLOSE_TAG = "</think>"
def __init__(self) -> None:
def __init__(self, *, allow_implicit_close: bool = False) -> None:
self._inside_think = False
self._pending = ""
self._channel_decided = not allow_implicit_close
@staticmethod
def _possible_tag_prefix_size(content: str, tag: str) -> int:
@@ -44,6 +45,23 @@ class InlineThinkTagFilter:
visible: list[str] = []
thinking: list[str] = []
if not self._channel_decided:
lowered = remaining.lower()
open_at = lowered.find(self._OPEN_TAG)
close_at = lowered.find(self._CLOSE_TAG)
if close_at >= 0 and (open_at < 0 or close_at < open_at):
# Some templates inject the opening tag outside returned
# content. Keep the ambiguous prefix private until its close
# marker arrives, even when that marker spans chunks.
thinking.append(remaining[:close_at])
remaining = remaining[close_at + len(self._CLOSE_TAG) :]
self._channel_decided = True
elif open_at >= 0:
self._channel_decided = True
else:
self._pending = remaining
return "", ""
while remaining:
tag = self._CLOSE_TAG if self._inside_think else self._OPEN_TAG
marker_at = remaining.lower().find(tag)
@@ -65,8 +83,27 @@ class InlineThinkTagFilter:
"""Compatibility helper returning only confirmed visible text."""
return self.push_parts(chunk)[0]
def confirm_visible_channel(self) -> str:
"""Stop close-only probing and return any buffered visible prelude.
A provider that emits a dedicated reasoning field has already told us
how to classify its trace. Its ordinary ``content`` channel can then
stream immediately even when the model supports thinking.
"""
if self._channel_decided:
return ""
self._channel_decided = True
pending = self._pending
self._pending = ""
return pending
def finish_parts(self) -> tuple[str, str]:
"""Flush the remaining visible or thinking text at end of stream."""
if not self._channel_decided:
tail = self._pending
self._pending = ""
self._channel_decided = True
return tail, ""
if self._inside_think:
thinking = self._pending
self._pending = ""